Calculer le plus grand rectangle dans une rotation du rectangle

Je suis juste venu ici à la recherche pour la même réponse. Après de frémir à la pensée de tant de mathématiques impliqués, j'ai pensé que je pourrais recourir à une demi-instruits deviner. Gribouille un peu je suis arrivé à l' (intuitive et peut-être pas entièrement exact) conclusion que le plus grand rectangle est proportionnelle à l'extérieur rectangle résultant, et de ses deux coins opposés se situent à l'intersection des diagonales du rectangle extérieur avec le côté le plus long de la rotation d'un rectangle. Pour les places, les diagonales et les côtés ferais... je pense que je suis assez heureux avec cela et il va maintenant commencer à brosser les toiles d'araignée de mon rusty trig compétences (pathétique, je sais).

Mise à jour mineure... Réussi à faire quelques calculs trigonométriques. C'est pour le cas lorsque la Hauteur de l'image est plus grande que la Largeur.

Mise à jour. Obtenu la chose entière de travail. Voici quelques code js. Il est connecté à un programme plus large, et la plupart des variables sont hors de la portée des fonctions et sont modifiés directement dans les fonctions. Je sais que ce n'est pas bon, mais je suis en utilisant ce dans une situation d'isolement, où il n'y aura pas de confusion avec d'autres scripts: rédigé

---

J'ai pris la liberté de nettoyage du code et en l'extrayant d'une fonction:

function getCropCoordinates(angleInRadians, imageDimensions) {
    var ang = angleInRadians;
    var img = imageDimensions;

    var quadrant = Math.floor(ang /(Math.PI /2)) & 3;
    var sign_alpha = (quadrant & 1) === 0 ? ang : Math.PI - ang;
    var alpha = (sign_alpha % Math.PI + Math.PI) % Math.PI;

    var bb = {
        w: img.w * Math.cos(alpha) + img.h * Math.sin(alpha),
        h: img.w * Math.sin(alpha) + img.h * Math.cos(alpha)
    };

    var gamma = img.w < img.h ? Math.atan2(bb.w, bb.h) : Math.atan2(bb.h, bb.w);

    var delta = Math.PI - alpha - gamma;

    var length = img.w < img.h ? img.h : img.w;
    var d = length * Math.cos(alpha);
    var a = d * Math.sin(alpha) /Math.sin(delta);

    var y = a * Math.cos(gamma);
    var x = y * Math.tan(gamma);

    return {
        x: x,
        y: y,
        w: bb.w - 2 * x,
        h: bb.h - 2 * y
    };
}

J'ai rencontré quelques problèmes avec le gamma-calcul, et l'a modifié pour tenir compte de la direction dans laquelle la boîte d'origine est la plus longue.

-- Magnus Hoff

D'abord, nous prenons en charge le cas trivial où l'angle est égal à zéro ou à un multiple de pi/2. Puis le plus grand rectangle est le même que l'original rectangle.

En général, le rectangle intérieur dispose de 3 points sur les limites du rectangle extérieur. Si elle ne le fait pas, alors il peut être déplacé de façon que l'un des vertex sera sur le fond, et un sommet sera sur la gauche. Vous pouvez ensuite agrandir le rectangle intérieur jusqu'à ce que l'un des deux sommets restants atteint une limite.

Nous appelons les côtés du rectangle extérieur R1 et R2. Sans perte de généralité, nous pouvons supposer que R1 <= R2. Si nous appelons les côtés du rectangle intérieur H et W, nous avons alors que

H cos a + W sin a <= R1
H sin a + W cos a <= R2

Puisque nous avons au moins 3 points sur les frontières, au moins l'un de ces inégalités doivent être en fait une égalité. Nous allons utiliser la première. Il est facile de voir que:

W = (R1 - H cos a) /sin a

et de sorte que la zone est

A = H W = H (R1 - H cos a) /sin a

Nous pouvons prendre les dérivés wrt. H et de demander à être égale à 0:

dA/dH = ((R1 - H cos a) - H cos a) /sin a

De problèmes pour H et en utilisant l'expression de W, ci-dessus, nous constatons que:

H = R1 /(2 cos a)
W = R1 /(2 sin a)

En substituant ceci dans la deuxième inégalité devient, après quelques manipulations,

R1 (tan a + 1/tan a) /2 <= R2

Le facteur sur le côté gauche est toujours au moins 1. Si l'inégalité est satisfaite, alors nous avons la solution. Si elle n'est pas satisfaite, alors la solution est la seule qui satisfasse à la fois les inégalités que les égalités. En d'autres termes: c'est le rectangle qui touche tous les quatre côtés du rectangle extérieur. C'est un système linéaire avec 2 inconnues, qui est facilement résolu:

H = (R2 cos a - R1 sin a) /cos 2a
W = (R1 cos a - R2 sin a) /cos 2a

En termes de coordonnées d'origine, on obtient:

x1 = x4 = W sin a cos a
y1 = y2 = R2 sin a - W sin^2 a 
x2 = x3 = x1 + H
y3 = y4 = y2 + W

@Andri ne fonctionne pas correctement pour l'image où width > height que j'ai testé.
Donc, j'ai corrigé et optimisé son code par un tel moyen (avec seulement deux fonctions trigonométriques):

calculateLargestRect = function(angle, origWidth, origHeight) {
    var w0, h0;
    if (origWidth <= origHeight) {
        w0 = origWidth;
        h0 = origHeight;
    }
    else {
        w0 = origHeight;
        h0 = origWidth;
    }
    //Angle normalization in range [-PI..PI)
    var ang = angle - Math.floor((angle + Math.PI) /(2*Math.PI)) * 2*Math.PI; 
    ang = Math.abs(ang);      
    if (ang > Math.PI /2)
        ang = Math.PI - ang;
    var sina = Math.sin(ang);
    var cosa = Math.cos(ang);
    var sinAcosA = sina * cosa;
    var w1 = w0 * cosa + h0 * sina;
    var h1 = w0 * sina + h0 * cosa;
    var c = h0 * sinAcosA /(2 * h0 * sinAcosA + w0);
    var x = w1 * c;
    var y = h1 * c;
    var w, h;
    if (origWidth <= origHeight) {
        w = w1 - 2 * x;
        h = h1 - 2 * y;
    }
    else {
        w = h1 - 2 * y;
        h = w1 - 2 * x;
    }
    return {
        w: w,
        h: h
    }
}

Mise à JOUR

Aussi j'ai décidé de poster la fonction suivante proportionnelle rectange calcul:

calculateLargestProportionalRect = function(angle, origWidth, origHeight) {
    var w0, h0;
    if (origWidth <= origHeight) {
        w0 = origWidth;
        h0 = origHeight;
    }
    else {
        w0 = origHeight;
        h0 = origWidth;
    }
    //Angle normalization in range [-PI..PI)
    var ang = angle - Math.floor((angle + Math.PI) /(2*Math.PI)) * 2*Math.PI; 
    ang = Math.abs(ang);      
    if (ang > Math.PI /2)
        ang = Math.PI - ang;
    var c = w0 /(h0 * Math.sin(ang) + w0 * Math.cos(ang));
    var w, h;
    if (origWidth <= origHeight) {
        w = w0 * c;
        h = h0 * c;
    }
    else {
        w = h0 * c;
        h = w0 * c;
    }
    return {
        w: w,
        h: h
    }
}

désolé de ne pas donner une dérivation ici, mais j'ai résolu ce problème en Mathematica il y a quelques jours et est venu avec la procédure suivante, qui non-Mathematica gens devraient être en mesure de lire. En cas de doute, veuillez consulter http://reference.wolfram.com/mathematica/guide/Mathematica.html

La procédure ci-dessous renvoie la largeur et la hauteur d'un rectangle avec un maximum de zone qui s'insère dans un autre rectangle de largeur w et de hauteur h qui a été tourné par alpha.

CropRotatedDimensionsForMaxArea[{w_, h_}, alpha_] := 
With[
  {phi = Abs@Mod[alpha, Pi, -Pi/2]},
  Which[
   w == h, {w,h} Csc[phi + Pi/4]/Sqrt[2],
   w > h, 
     If[ Cos[2 phi]^2 < 1 - (h/w)^2, 
       h/2 {Csc[phi], Sec[phi]}, 
       Sec[2 phi] {w Cos[phi] - h Sin[phi], h Cos[phi] - w Sin[phi]}],
   w < h, 
     If[ Cos[2 phi]^2 < 1 - (w/h)^2, 
       w/2 {Sec[phi], Csc[phi]}, 
       Sec[2 phi] {w Cos[phi] - h Sin[phi], h Cos[phi] - w Sin[phi]}]
  ]
]