Comment puis-je échelle d'un rectangle à la taille maximale possible dans un autre rectangle?

J'ai un rectangle source et un rectangle de destination. J'ai besoin de trouver le maximum de l'échelle à laquelle la source peut être réduite tout en s'inscrivant dans le rectangle de destination et en conservant son aspect d'origine.

Google a trouvé un façon de le faire mais je ne suis pas sûr si cela fonctionne dans tous les cas. Ici est ma maison brassée solution:

  • Calculer la Hauteur/Largeur de chaque rectangle. Cela donne les pentes des diagonales msrc et mdest.
  • Si msrc < mdst, à l'échelle de la source de largeur pour s'adapter à la destination largeur (et de la hauteur de l'échelle par le même ratio)
  • Contraire, l'échelle de la source de hauteur pour s'adapter à la destination hauteur (et de la largeur de l'échelle par le même ratio)

À la recherche d'autres solutions possibles à ce problème. Je ne suis même pas sûr si mon algorithme fonctionne dans tous les cas!

InformationsquelleAutor |
  1. 112
    scale = min( dst.width/src.width, dst.height/src.height)

    C'est votre approche, mais écrit de façon plus propre.

    • Sweet! Une fois que vous avez l'échelle, utilisez-les pour obtenir les dimensions finales: width = src.width * scale et height = src.height * scale
    • Changement de min à max si vous souhaitez couvrir toute la zone de destination.
    • Même solution, mais avec des noms plus clair pour moi: scale = min(maxWidth/actualWidth, maxHeight/actualHeight), newWidth = actualWidth*scale, newHeight = actualHeight*scale.
    InformationsquelleAutor
  2. 10

    Une autre option pourrait être à l'échelle de largeur maximale et de vérifier ensuite si l'échelle de hauteur supérieure à la hauteur maximale autorisée et, dans l'affirmative à l'échelle en fonction de la hauteur (ou vice versa):

    scale = (dst.width /src.width);
if (src.height * scale > dst.height)
 scale = dst.height /src.height;

    Je pense que cette solution est à la fois plus court, plus rapide et plus facile à comprendre.

    • Je pense que vous avez le ratio retournée dans votre troisième ligne.
    • vous avez absolument raison. je le fixe.
    InformationsquelleAutor Guss
  3. 1
    1. Travailler sur la plus petite des destWidth /srcWidth et destHeight /srcHeight
    2. Échelle par

    modifier bien sûr, c'est la même méthode, avec les pièces de la formule de déplacés. Mon avis est que c'est plus clair du point de vue sémantique, mais c'est seulement que - une opinion.

    InformationsquelleAutor AakashM
  4. 1

    Si toutes les dimensions sont non nuls, je voudrais utiliser le code suivant (qui, pour l'essentiel correspond à votre code).

    scaleFactor = (outerWidth /outerHeight > innerWidth /innerHeight) 
    ? outerHeight /innerHeight
    : outerWidth /innerWidth

    Cela peut également être modifié pour permettre à toute la dimension de zéro si nécessaire.

    • Je pense qu'un rectangle avec un zéro dimension, c'est la "ligne". 😛
    • Cette solution est mathématiquement identique à la mienne: multipliez vos inégalité (innerHeight * outerHeight / innerWidth) et vous obtenez mon inégalités. L'avantage de mon code, c'est que si les inégalités échoue, alors la solution n'a pas besoin d'être recalculées.
    • Le ternariy opérateur de l'évaluation de l'état qu'une seule fois, trop. Et, bien sûr, toutes les solutions doivent être mathématique équivalent ... ou mal ...
    • L'opérateur ternaire permettra d'évaluer la condition qu'une seule fois, mais par le formatage de la condition différemment dans le calcul de la condition peut être l'une des réponses. Notez que vous avez toujours 3 les opérations de multiplication dans le calcul. Ma solution a 3 opérations dans le pire des cas, sinon il n'en a que 2, parce que le bon calcul a déjà été fait avant le test. Donc, 1/6ème de meilleures performances (en supposant une distribution aléatoire de valeurs).
    InformationsquelleAutor
  5. 0

    Autres réponses souffrent d'un risque de générer une division par zéro exception lorsque le sourceWidth ou sourceHeight devient zéro. Pour éviter cette situation, nous devons réécrire la comparaison dans une mathématiquement équivalent de multiples expression. Aussi, d'autres de bord de la condition d'attraper l'infini à l'échelle scénario.

    En dehors d'avoir l'échelle, je voulais vraiment les dimensions du rectangle cible, donc, ici, je vais fournir à l'échelle de calcul et le rectangle cible de calcul.

    En raison du débordement de la condition, je pense que le rectangle cible sera plus robuste /utile:

        if (sourceWidth == 0 && sourceHeight == 0) {
        //scale = Infinity;
        outputWidth = 0;
        outputHeight = 0;
        outputX = destWidth /2;
        outputY = destHeight /2;
    } else if (destWidth * sourceHeight > destHeight * sourceWidth) {
        scale = destHeight /sourceHeight;
        outputWidth = sourceWidth * destHeight /sourceHeight;
        outputHeight = destHeight;
        outputX = (destWidth - outputWidth) /2;
        outputY = 0;
    } else {
        scale = destWidth /sourceWidth;
        outputWidth = destWidth;
        outputHeight = sourceHeight * destWidth /sourceWidth;
        outputX = 0;
        outputY = (destHeight - outputHeight) /2;
    }
    InformationsquelleAutor