4. Wie kann ich sachen rotiren ?????????

Wie kann ich sachen rotiren ?????????

  • *

    Hallo,

    Ich wolte mal fragen wie man bilder/graphiken (von c++ aus) rotieren kann (1°-360°)
    Bitte schreibt mor ein Beischpiel.

    Jetzt schon : vielen dank für die antworten 🙂

    0
  • A

    Hallo

    Jedenfalls nicht mit dem Builder. Ich weiß grad nicht ob die WinAPI entsprechende Funktionen bereitstellt, aber wahrscheinlich must du dir eine externe Grafik-Bibliothek einbinden. Schau also am besten im Grafik-Forum nach.

    bis bald
    akari

    0
  • A

    GDI+ bietet einige Möglichkeiten dafür.

    0
  • R

    Schau mal z.B. hier. Wenn Du dort nichts finden solltest, was zu Deiner BCB-Version passt, dann schau mal in die FAQ, wo Du noch nach anderen Komponenten suchen könntest.

    0
  • D

    akari schrieb:

    Hallo

    Jedenfalls nicht mit dem Builder. Ich weiß grad nicht ob die WinAPI entsprechende Funktionen bereitstellt, aber wahrscheinlich must du dir eine externe Grafik-Bibliothek einbinden. Schau also am besten im Grafik-Forum nach.

    bis bald
    akari

    Wieso nicht mit CBuilder?
    Sollte mit WinAPI gehen oder im CBuilder direkt (BCB 4.0):

    Quell und Zielbild GLEICH gross
    Beide Bilder pf24bit
    RotAngle in Bogenmass !!!
    ZoomFac kann 1.0 sein

    void __fastcall CalculateRotation(double &XOrgDbl, double &YOrgDbl, double SinAngle, double CosAngle)
{
  double XNew,YNew;
  XNew=XOrgDbl * CosAngle - YOrgDbl * SinAngle;
  YNew=YOrgDbl * CosAngle + XOrgDbl * SinAngle;
  XOrgDbl=XNew;
  YOrgDbl=YNew;
}

void __fastcall RotateTransform(Graphics::TBitmap *BMOrg,Graphics::TBitmap *BMDest,double RotAngle, double ZoomFac, Boolean Interpolate)
{
  double SinAngle,CosAngle;
  int X,Y,XOrg,YOrg;
  double XOrgDbl,YOrgDbl;
  int R,G,B;
  double DXOrgDbl,DYOrgDbl;
  double Eins_DXOrgDbl,Eins_DYOrgDbl;
  PRGBTriple DestRow,OrgRow,OrgRowNext;
  PRGBTriple *POrgRow=NULL;
  int BMWidth=BMOrg->Width;
  int BMHeight=BMOrg->Height;
  int BMW_2=BMWidth / 2;
  int BMH_2=BMHeight / 2;
  BMOrg->PixelFormat=pf24bit;
  BMDest->PixelFormat=pf24bit;
  SinAngle=sin(RotAngle);
  CosAngle=cos(RotAngle);
  try
  {
    BMDest->Width=BMWidth;
    BMDest->Height=BMHeight;
    POrgRow=(PRGBTriple*)malloc(sizeof(PRGBTriple) * BMHeight);
    if (POrgRow!=NULL)
    {
      for (int Zeile=0;Zeile<BMHeight;Zeile++)
      { POrgRow[Zeile]=(PRGBTriple)BMOrg->ScanLine[Zeile];
      }
      for (Y=0;Y<BMHeight;Y++)
      {

        DestRow=(PRGBTriple)BMDest->ScanLine[Y];
        for (X=0;X<BMWidth;X++)
        {
          XOrgDbl=(X - BMW_2) / ZoomFac;
          YOrgDbl=(Y - BMH_2) / ZoomFac;

          CalculateRotation(XOrgDbl,YOrgDbl,SinAngle,CosAngle);

          XOrgDbl=XOrgDbl + BMW_2;
          YOrgDbl=YOrgDbl + BMH_2;
          XOrg=int(XOrgDbl);
          YOrg=int(YOrgDbl);
          if ((XOrg>=0) && (YOrg>=0) && (XOrg<BMWidth) && (YOrg<BMHeight))
          {
            OrgRow=POrgRow[YOrg];
            if (Interpolate)
            { if (YOrg<(BMHeight - 1))
              { OrgRowNext=POrgRow[YOrg + 1];
              }
              else
              { OrgRowNext=NULL;
              }
              //Interpolation ueber 2 Zeilen
              if (OrgRowNext!=NULL)
              {
                //Interpolation ueber 4 Pixel / 2 Zeilen
                if (XOrg<(BMWidth - 1))
                {
                  DXOrgDbl=XOrgDbl - XOrg;
                  DYOrgDbl=YOrgDbl - YOrg;
                  Eins_DXOrgDbl=1-DXOrgDbl;
                  Eins_DYOrgDbl=1-DYOrgDbl;
                  R=(OrgRow[XOrg].rgbtRed * (Eins_DXOrgDbl)+ OrgRow[XOrg + 1].rgbtRed * DXOrgDbl) * (Eins_DYOrgDbl);
                  G=(OrgRow[XOrg].rgbtGreen * (Eins_DXOrgDbl) + OrgRow[XOrg + 1].rgbtGreen * DXOrgDbl) * (Eins_DYOrgDbl);
                  B=(OrgRow[XOrg].rgbtBlue * (Eins_DXOrgDbl) + OrgRow[XOrg + 1].rgbtBlue * DXOrgDbl) * (Eins_DYOrgDbl);
                  R=R + (OrgRowNext[XOrg].rgbtRed * (Eins_DXOrgDbl)+ OrgRowNext[XOrg + 1].rgbtRed * DXOrgDbl) * DYOrgDbl;
                  G=G + (OrgRowNext[XOrg].rgbtGreen * (Eins_DXOrgDbl) + OrgRowNext[XOrg + 1].rgbtGreen * DXOrgDbl) * DYOrgDbl;
                  B=B + (OrgRowNext[XOrg].rgbtBlue * (Eins_DXOrgDbl) + OrgRowNext[XOrg + 1].rgbtBlue * DXOrgDbl) * DYOrgDbl;
                  DestRow[X].rgbtRed=(unsigned char)R;
                  DestRow[X].rgbtGreen=(unsigned char)G;
                  DestRow[X].rgbtBlue=(unsigned char)B;
                }
                //Interpolation ueber 2 Pixel/ 2 Zeilen
                else
                {
                  DestRow[X].rgbtRed=OrgRow[XOrg].rgbtRed;
                  DestRow[X].rgbtGreen=OrgRow[XOrg].rgbtGreen;
                  DestRow[X].rgbtBlue=OrgRow[XOrg].rgbtBlue;
                }
              }
              //Interpolation ueber 1 Zeile
              else
              {
                //interpolation ueber 2 Pixel / 1 Zeile
                if (XOrg<(BMWidth - 1))
                {
                  DXOrgDbl=XOrgDbl - XOrg;
                  DYOrgDbl=YOrgDbl - YOrg;
                  Eins_DXOrgDbl=1-DXOrgDbl;
                  Eins_DYOrgDbl=1-DYOrgDbl;
                  R=OrgRow[XOrg].rgbtRed * (Eins_DXOrgDbl)+ OrgRow[XOrg + 1].rgbtRed * DXOrgDbl;
                  G=OrgRow[XOrg].rgbtGreen * (Eins_DXOrgDbl) + OrgRow[XOrg + 1].rgbtGreen * DXOrgDbl;
                  B=OrgRow[XOrg].rgbtBlue * (Eins_DXOrgDbl) + OrgRow[XOrg + 1].rgbtBlue * DXOrgDbl;
                  DestRow[X].rgbtRed=(unsigned char)R;
                  DestRow[X].rgbtGreen=(unsigned char)G;
                  DestRow[X].rgbtBlue=(unsigned char)B;
                }
                //keine Interpolation
                else
                {
                  DestRow[X].rgbtRed=OrgRow[XOrg].rgbtRed;
                  DestRow[X].rgbtGreen=OrgRow[XOrg].rgbtGreen;
                  DestRow[X].rgbtBlue=OrgRow[XOrg].rgbtBlue;
                }
              }
            }
            else
            {
              DestRow[X].rgbtRed=OrgRow[XOrg].rgbtRed;
              DestRow[X].rgbtGreen=OrgRow[XOrg].rgbtGreen;
              DestRow[X].rgbtBlue=OrgRow[XOrg].rgbtBlue;
            }
          }
          else
          {
            DestRow[X].rgbtRed=0;
            DestRow[X].rgbtGreen=0;
            DestRow[X].rgbtBlue=0;
          }
        }
      }
    }
    else
    { //Fehler aufgetreten
    }
  }
  catch(...)
  {
  }
}
    0
  • A

    Hallo

    Ja man kann sich natürlich auch im Builder eine eigene Rotationsfunktion schreiben. Ich dachte aber eher an eine schon vorhandene Funktion, und da bietet die VCL nichts. Da ich nicht nicht wußte ob WinAPI eine hat hab ich dann gleich an richtige Grafik-Libs verwiesen.

    bis bald
    akari

    0
Anmelden zum Antworten