獲取正確的多邊形以在圖像中顯示

現在確實需要您的幫助獲取正確的多邊形以在圖像中顯示

我有一些檢測結果。

，我希望表現出這種非旋轉圖像這個結果（請忽略藍色框）

我對我的算法邏輯如下

鑑於黃色框的座標是參照參考框架（圖1的左上角），我試圖找到黃色框的座標，參考框架圖像1內部圖像的左上角的參考。

所以我使用了基本的trigno（圖像1右下角的直角三角形，以獲得圖像1的左上角的座標）內部圖像並參考此點找到黃色框的座標。

之後我使用，因爲我想在圖像2上顯示結果，我用內部圖像的中心作爲我的旋轉點，並將黃色框相對於此中心的座標轉換爲內部的原點圖像（頂部左手角落），然後轉動使用這種矩陣：

enter image description here [X，Y]，其中[X，Y]是用於我的觀點

我的圖像上所得的多邊形是這樣的：

enter image description here

我的教授看了看，並說這是錯誤的。

我已經失去了多少次，我經歷了邏輯和實施...這似乎對我來說是正確的。任何善良的靈魂能幫助我嗎？

這裏是我的代碼部分：

// 135度

else if(nameForcompare.equals("135")){ 
     angle = 225; 
     minPoint.set_y(catYmin); minPoint.set_x(catXmin); maxPoint.set_y(catYmax); maxPoint.set_x(catXmax); 
     //Show detection results of rotated image 
     g5.setColor(Color.YELLOW); 
     g5.drawRect((int)minPoint.get_x(), (int)minPoint.get_y(), (int)(maxPoint.get_x()-minPoint.get_x()), (int)(maxPoint.get_y()-minPoint.get_y())); 


     rotatedX = Double.parseDouble(originalWidth)*Math.cos(Math.toRadians((int)45)); 
     if(catXmin < rotatedX){ 
       o = imageHeight - catYmin; 
       a = rotatedX - catXmin; 
       theta = Math.atan(o/a); 
       h = (o/Math.sin(theta)); 

      if(theta >= Math.toRadians((int)45)){ 
       thetaZ = theta - Math.toRadians((int)45); 

       oZ = h*Math.sin(thetaZ); //ycoordinate 
       aZ = h*Math.cos(thetaZ); //xcoordinate 

       varX = checkPointsBeforeRotationX(aZ); 
       varY = checkPointsBeforeRotationY(oZ); 
      } 
      else{ 
       thetaZ = Math.toRadians((int)45) - theta; 
       oZ = 0;     //ycoordinate 
       aZ = h*Math.cos(thetaZ); //xcoordinate 

       varX = checkPointsBeforeRotationX(aZ); 
       varY = checkPointsBeforeRotationY(oZ);     

      } 
       minPoint.set_x(varX); 
       minPoint.set_y(varY); 

     } 
     else if(catXmin == rotatedX){ 
      theta = Math.toRadians((int)45); 
      h = imageHeight - catYmin; 

      o = h*Math.sin(theta); //ycoordinate 
      a = h*Math.cos(theta); //xcoordinate 

      varX = checkPointsBeforeRotationX(a); 
      varY = checkPointsBeforeRotationY(o);     

      minPoint.set_y(varY); 
      minPoint.set_x(varX); 
     } 
     else if(catXmin > rotatedX){ 
      a = imageHeight - catYmin; 
      o = catXmin - rotatedX; 
      theta = Math.atan(o/a); 
      h = (o/Math.sin(theta)); 
     if(theta <= Math.toRadians((int)45)){  
      thetaZ = theta + Math.toRadians((int)45); 

      oZ = h*Math.sin(thetaZ); //ycoordinate 
      aZ = h*Math.cos(thetaZ); //xcoordinate 

      varX = checkPointsBeforeRotationX(aZ); 
      varY = checkPointsBeforeRotationY(oZ); 
     } 
     else{ 
      thetaZ = Math.toRadians((int)45) - theta; 

      oZ = 0;     //xcoordinate 
      aZ = h*Math.cos(thetaZ); //ycoordinate 

      varX = checkPointsBeforeRotationX(oZ); 
      varY = checkPointsBeforeRotationY(aZ); 

     } 
      minPoint.set_x(varX); 
      minPoint.set_y(varY); 

     } 

     if(catXmax < rotatedX){ 
       o = imageHeight - catYmax; 
       a = rotatedX - catXmax; 
       theta = Math.atan(o/a); 
       h = (o/Math.sin(theta)); 
     if(theta >= Math.toRadians((int)45)){   
       thetaZ = theta - Math.toRadians((int)45); 

       oZ = h*Math.sin(thetaZ); //ycoordinate 
       aZ = h*Math.cos(thetaZ); //xcoordinate 

       varX = checkPointsBeforeRotationX(aZ); 
       varY = checkPointsBeforeRotationY(oZ); 
     } 
     else{ 
       thetaZ = Math.toRadians((int)45) - theta; 
       oZ = 0;     //ycoordinate 
       aZ = h*Math.cos(thetaZ); //xcoordinate 

       varX = checkPointsBeforeRotationX(aZ); 
       varY = checkPointsBeforeRotationY(oZ); 
     } 
       maxPoint.set_x(varX); 
       maxPoint.set_y(varY); 

     } 
     else if(catXmax == rotatedX){ 
      theta = Math.toRadians((int)45); 
      h = imageHeight - catYmin; 

      o = h*Math.sin(theta); //ycoordinate 
      a = h*Math.cos(theta); //xcoordinate 

      varX = checkPointsBeforeRotationX(a); 
      varY = checkPointsBeforeRotationY(o); 

      maxPoint.set_y(varY); 
      maxPoint.set_x(varX); 

     } 
     else if(catXmax > rotatedX){ 
      a = imageHeight - catYmax; 
      o = catXmax - rotatedX; 
      theta = Math.atan(o/a); 
      h = (o/Math.sin(theta)); 
     if(theta <= Math.toRadians((int)45)){  
      thetaZ = theta + Math.toRadians((int)45); 

      oZ = h*Math.sin(thetaZ); //ycoordinate 
      aZ = h*Math.cos(thetaZ); //xcoordinate 

      varX = checkPointsBeforeRotationX(aZ); 
      varY = checkPointsBeforeRotationY(oZ); 
     } 
     else{ 
      thetaZ = Math.toRadians((int)45) - theta; 

      oZ = 0;     //xcoordinate 
      aZ = h*Math.cos(thetaZ); //ycoordinate 

      varX = checkPointsBeforeRotationX(oZ); 
      varY = checkPointsBeforeRotationY(aZ); 
     } 

      maxPoint.set_y(varX); 
      maxPoint.set_x(varY); 

     } 

     getCorners(); 
     checkPointsAfterRotation(angle); 
     checkCornerPointsAfterRotation(angle); 

     g2.setColor(Color.MAGENTA); 
     g2.drawPolygon(xPoints, yPoints, nPoints); 
     Corners1 =0; Corners2 =0; 








public static void rotate2(Point originForRotation, Point pointForRotation, Double angle){ 
double cos=Math.cos(angle); 
double sin=Math.sin(angle); 
double oX =originForRotation.get_x(); 
double oY =originForRotation.get_y(); 
double x=pointForRotation.get_x(); 
double y=pointForRotation.get_y(); 

x = x-oX; y = y-oY; 


pointForRotation.set_x((cos*x-sin*y)+oX); 
pointForRotation.set_y((sin*x+cos*y)+oY);  

pointForRotation.show(); 

} 

public static void getCorners(){ 
    if((minPoint.get_x() > maxPoint.get_x()) && (minPoint.get_y() < maxPoint.get_y())){ 
     topleftPoint.set_x(maxPoint.get_x()); bottomrightPoint.set_x(minPoint.get_x()); 
     topleftPoint.set_y(minPoint.get_y()); bottomrightPoint.set_y(maxPoint.get_y()); 
     Corners1 = 1; 
    } 
    else if((minPoint.get_x() > maxPoint.get_x()) && (minPoint.get_y() > maxPoint.get_y())){ 
     toprightPoint.set_x(minPoint.get_x()); bottomleftPoint.set_x(maxPoint.get_x()); 
     toprightPoint.set_y(maxPoint.get_y()); bottomleftPoint.set_y(minPoint.get_y()); 
     Corners2 = 1; 
    } 
    else if((minPoint.get_x() < maxPoint.get_x()) && (minPoint.get_y() < maxPoint.get_y())){ 
     toprightPoint.set_x(maxPoint.get_x()); bottomleftPoint.set_x(minPoint.get_x()); 
     toprightPoint.set_y(minPoint.get_y()); bottomleftPoint.set_y(maxPoint.get_y()); 
     Corners2 = 1; 
    } 
    else if((minPoint.get_x() < maxPoint.get_x()) && (minPoint.get_y() > maxPoint.get_y())){ 
     topleftPoint.set_x(minPoint.get_x()); bottomrightPoint.set_x(maxPoint.get_x()); 
     topleftPoint.set_y(maxPoint.get_y()); bottomrightPoint.set_y(minPoint.get_y()); 
     Corners1 = 1; 
    } 
} 

public static Double checkPointsBeforeRotationX(Double pointX){ 
    if(pointX > (Double.parseDouble(originalWidth))){ 
     pointX = Double.parseDouble(originalWidth); 
     } 
    return pointX; 
} 

public static Double checkPointsBeforeRotationY(Double pointY){ 
    if(pointY > (Double.parseDouble(originalHeight))){ 
     pointY = Double.parseDouble(originalHeight); 
    } 
    return pointY; 
} 

public static void checkPointsAfterRotation(int angle){ 

     rotate2(origin, minPoint, Math.toRadians((int)angle));  
     rotate2(origin, maxPoint, Math.toRadians((int)angle)); 
     //check for out of bound points after rotation 
      if(minPoint.get_y()< 0){ 
       minPoint.set_y(0); 
      } 
      else if(minPoint.get_y() > Double.parseDouble(originalHeight)){ 
       minPoint.set_y(Double.parseDouble(originalHeight)); 
      } 
      if(minPoint.get_x()< 0){ 
       minPoint.set_x(0); 
      } 
      else if(minPoint.get_x() > Double.parseDouble(originalWidth)){ 
       minPoint.set_x(Double.parseDouble(originalWidth)); 
      } 
      if(maxPoint.get_y()< 0){ 
       maxPoint.set_y(0); 
      } 
      else if(maxPoint.get_y() > Double.parseDouble(originalHeight)){ 
       maxPoint.set_y(Double.parseDouble(originalHeight)); 
      } 
      if(maxPoint.get_x()< 0){ 
       maxPoint.set_x(0); 
      } 
      else if(maxPoint.get_x() > Double.parseDouble(originalWidth)){ 
       maxPoint.set_x(Double.parseDouble(originalWidth)); 
      } 

     xPoints[0] = (int)minPoint.get_x(); 
     xPoints[2] = (int)maxPoint.get_x(); 

     yPoints[0] = (int)minPoint.get_y(); 
     yPoints[2] = (int)maxPoint.get_y(); 


} 


public static void checkCornerPointsAfterRotation(int angle){ 

    if(Corners1 == 0 && Corners2 == 1){ 

     rotate2(origin, toprightPoint, Math.toRadians((int)angle));  
     rotate2(origin, bottomleftPoint, Math.toRadians((int)angle)); 

     if(toprightPoint.get_y()< 0){ 
       toprightPoint.set_y(0); 
      } 
      else if(toprightPoint.get_y() > Double.parseDouble(originalHeight)){ 
       toprightPoint.set_y(Double.parseDouble(originalHeight)); 
      } 
      if(toprightPoint.get_x()< 0){ 
       toprightPoint.set_x(0); 
      } 
      else if(toprightPoint.get_x() > Double.parseDouble(originalWidth)){ 
       toprightPoint.set_x(Double.parseDouble(originalWidth)); 
      } 
      if(bottomleftPoint.get_y()< 0){ 
       bottomleftPoint.set_y(0); 
      } 
      else if(bottomleftPoint.get_y() > Double.parseDouble(originalHeight)){ 
       bottomleftPoint.set_y(Double.parseDouble(originalHeight)); 
      } 
      if(bottomleftPoint.get_x()< 0){ 
       bottomleftPoint.set_x(0); 
      } 
      else if(bottomleftPoint.get_x() > Double.parseDouble(originalWidth)){ 
       bottomleftPoint.set_x(Double.parseDouble(originalWidth)); 
      } 

      xPoints[1] = (int)toprightPoint.get_x(); xPoints[3] = (int)bottomleftPoint.get_x(); 
      yPoints[1] = (int)toprightPoint.get_y(); yPoints[3] = (int)bottomleftPoint.get_y(); 
     } 
     else if(Corners1 == 1 && Corners2 == 0){ 


     rotate2(origin, topleftPoint, Math.toRadians((int)angle));  
     rotate2(origin, bottomrightPoint, Math.toRadians((int)angle));  

     if(topleftPoint.get_y()< 0){ 
       topleftPoint.set_y(0); 
      } 
      else if(topleftPoint.get_y() > Double.parseDouble(originalHeight)){ 
       topleftPoint.set_y(Double.parseDouble(originalHeight)); 
      } 
      if(topleftPoint.get_x()< 0){ 
       topleftPoint.set_x(0); 
      } 
      else if(topleftPoint.get_x() > Double.parseDouble(originalWidth)){ 
       topleftPoint.set_x(Double.parseDouble(originalWidth)); 
      } 
      if(bottomrightPoint.get_y()< 0){ 
       bottomrightPoint.set_y(0); 
      } 
      else if(bottomrightPoint.get_y() > Double.parseDouble(originalHeight)){ 
       bottomrightPoint.set_y(Double.parseDouble(originalHeight)); 
      } 
      if(bottomrightPoint.get_x()< 0){ 
       bottomrightPoint.set_x(0); 
      } 
      else if(bottomrightPoint.get_x() > Double.parseDouble(originalWidth)){ 
       bottomrightPoint.set_x(Double.parseDouble(originalWidth)); 
      } 

      xPoints[1] = (int)topleftPoint.get_x(); xPoints[3] = (int)bottomrightPoint.get_x(); 
      yPoints[1] = (int)topleftPoint.get_y(); yPoints[3] = (int)bottomrightPoint.get_y(); 
     } 
}

來源

2013-03-13 user1968818

用於旋轉圖像的代碼太過分了代碼詳細跟蹤過，但我會假設你的代碼忠實工具你描述的數學。我認爲問題在於你正在應用一個純旋轉矩陣。從旋轉的小貓到旋轉的黃色框的轉變是翻譯和旋轉的組合。您需要首先將kitty（和黃色框）從（x，y）轉換爲（0,0）（因此旋轉後的kitty圖像位於圖1左上角的kitty左上角）。然後你需要順時針旋轉135度。

使用齊次座標和矩陣乘法將使您的代碼更加簡單。

來源

2013-03-13 03:38:12

如果你錯過了，我解釋說我的算法實際上同時使用平移和旋轉。然而，不是你建議的，我找到了我的小貓圖像的中心，並將它翻譯爲圖1的左上角，並且中心周圍的黃色框的座標也被翻譯。之後，我將圖像逆時針旋轉225度。這是否與你建議的一樣？ – user1968818 2013-03-13 03:49:41

@ user1968818 - 我建議將小貓圖片的左上角翻譯爲圖1的左上角。我忽略提到旋轉應該在圖1的左上角左右;我認爲這是原點。如果您翻譯中心，那麼如果您將中心翻譯迴旋轉後應該出現的位置，這將起作用。（否則，小貓形象將最終集中在圖1的左上角。） – 2013-03-13 05:32:31

獲取正確的多邊形以在圖像中顯示

回答

相關問題