vcl/backendtest/outputdevice/common.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  */
  10
  11 #include <test/outputdevice.hxx>
  12 #include <bitmapwriteaccess.hxx>
  13
  14 namespace vcl {
  15 namespace test {
  16
  17 namespace
  18 {
  19
  20 int deltaColor(BitmapColor aColor1, BitmapColor aColor2)
  21 {
  22     int deltaR = std::abs(aColor1.GetRed()   - aColor2.GetRed());
  23     int deltaG = std::abs(aColor1.GetGreen() - aColor2.GetGreen());
  24     int deltaB = std::abs(aColor1.GetBlue()  - aColor2.GetBlue());
  25
  26     return std::max(std::max(deltaR, deltaG), deltaB);
  27 }
  28
  29 void checkValue(BitmapScopedWriteAccess& pAccess, int x, int y, Color aExpected,
  30                       int& nNumberOfQuirks, int& nNumberOfErrors, bool bQuirkMode, int nColorDeltaThresh = 0)
  31 {
  32     const bool bColorize = false;
  33     Color aColor = pAccess->GetPixel(y, x);
  34     int nColorDelta = deltaColor(aColor, aExpected);
  35
  36     if (nColorDelta <= nColorDeltaThresh)
  37     {
  38         if (bColorize)
  39             pAccess->SetPixel(y, x, COL_LIGHTGREEN);
  40     }
  41     else if (bQuirkMode)
  42     {
  43         nNumberOfQuirks++;
  44         if (bColorize)
  45             pAccess->SetPixel(y, x, COL_YELLOW);
  46     }
  47     else
  48     {
  49         nNumberOfErrors++;
  50         if (bColorize)
  51             pAccess->SetPixel(y, x, COL_LIGHTRED);
  52     }
  53 }
  54
  55 TestResult checkRect(Bitmap& rBitmap, int aLayerNumber, Color aExpectedColor)
  56 {
  57     BitmapScopedWriteAccess pAccess(rBitmap);
  58     long nHeight = pAccess->Height();
  59     long nWidth = pAccess->Width();
  60
  61     long firstX = 0 + aLayerNumber;
  62     long firstY = 0 + aLayerNumber;
  63
  64     long lastX = nWidth  - aLayerNumber - 1;
  65     long lastY = nHeight - aLayerNumber - 1;
  66
  67     TestResult aResult = TestResult::Passed;
  68     int nNumberOfQuirks = 0;
  69     int nNumberOfErrors = 0;
  70
  71     // check corner quirks
  72     checkValue(pAccess, firstX, firstY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
  73     checkValue(pAccess, lastX,  firstY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
  74     checkValue(pAccess, firstX, lastY,  aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
  75     checkValue(pAccess, lastX,  lastY,  aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
  76
  77     for (long y = firstY + 1; y <= lastY - 1; y++)
  78     {
  79         checkValue(pAccess, firstX, y,  aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
  80         checkValue(pAccess, lastX,  y,  aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
  81     }
  82     for (long x = firstX + 1; x <= lastX - 1; x++)
  83     {
  84         checkValue(pAccess, x, firstY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
  85         checkValue(pAccess, x, lastY,  aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
  86     }
  87     if (nNumberOfQuirks > 0)
  88         aResult = TestResult::PassedWithQuirks;
  89     if (nNumberOfErrors > 0)
  90         aResult = TestResult::Failed;
  91     return aResult;
  92 }
  93
  94 TestResult checkHorizontalVerticalDiagonalLines(Bitmap& rBitmap, Color aExpectedColor, int nColorThresh)
  95 {
  96     BitmapScopedWriteAccess pAccess(rBitmap);
  97     long nWidth  = pAccess->Width();
  98     long nHeight = pAccess->Height();
  99
 100     TestResult aResult = TestResult::Passed;
 101     int nNumberOfQuirks = 0;
 102     int nNumberOfErrors = 0;
 103
 104     // check horizontal line
 105     {
 106         long startX = 4;
 107         long endX   = nWidth - 2;
 108
 109         long y = 1;
 110
 111         checkValue(pAccess, startX, y, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true, nColorThresh);
 112         checkValue(pAccess, endX,   y, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true, nColorThresh);
 113
 114         for (long x = startX + 1; x <= endX - 1; x++)
 115         {
 116             checkValue(pAccess, x, y, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false, nColorThresh);
 117         }
 118     }
 119
 120     // check vertical line
 121     {
 122         long startY = 4;
 123         long endY   = nHeight - 2;
 124
 125         long x = 1;
 126
 127         checkValue(pAccess, x, startY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true, nColorThresh);
 128         checkValue(pAccess, x, endY,   aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true, nColorThresh);
 129
 130         for (long y = startY + 1; y <= endY - 1; y++)
 131         {
 132             checkValue(pAccess, x, y, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false, nColorThresh);
 133         }
 134     }
 135
 136     // check diagonal line
 137     {
 138         long startX = 1;
 139         long endX   = nWidth - 2;
 140
 141         long startY = 1;
 142         long endY   = nHeight - 2;
 143
 144         long x = startX;
 145         long y = startY;
 146
 147         checkValue(pAccess, startX, startY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true, nColorThresh);
 148         checkValue(pAccess, endX,   endY,   aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true, nColorThresh);
 149
 150         x++; y++;
 151
 152         while(y <= endY - 1  && x <= endX - 1)
 153         {
 154             checkValue(pAccess, x, y, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false, nColorThresh);
 155             x++; y++;
 156         }
 157     }
 158
 159     if (nNumberOfQuirks > 0)
 160         aResult = TestResult::PassedWithQuirks;
 161     if (nNumberOfErrors > 0)
 162         aResult = TestResult::Failed;
 163     return aResult;
 164 }
 165
 166 TestResult checkDiamondLine(Bitmap& rBitmap, int aLayerNumber, Color aExpectedColor)
 167 {
 168     BitmapScopedWriteAccess pAccess(rBitmap);
 169     long nHeight = pAccess->Height();
 170     long nWidth = pAccess->Width();
 171
 172     long midX = nWidth  / 2;
 173     long midY = nHeight / 2;
 174
 175     long firstX = aLayerNumber;
 176     long lastX  = nWidth - aLayerNumber - 1;
 177
 178     long firstY = aLayerNumber;
 179     long lastY  = nHeight - aLayerNumber - 1;
 180
 181     long offsetFromMid = 0;
 182
 183     TestResult aResult = TestResult::Passed;
 184     int nNumberOfQuirks = 0;
 185     int nNumberOfErrors = 0;
 186
 187     checkValue(pAccess, firstX, midY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
 188     checkValue(pAccess, lastX,  midY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
 189     checkValue(pAccess, midX, firstY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
 190     checkValue(pAccess, midX,  lastY, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, true);
 191
 192     offsetFromMid = 1;
 193     for (long x = firstX + 1; x <= midX - 1; x++)
 194     {
 195         checkValue(pAccess, x, midY - offsetFromMid, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
 196         checkValue(pAccess, x, midY + offsetFromMid, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
 197
 198         offsetFromMid++;
 199     }
 200
 201     offsetFromMid = midY - aLayerNumber - 1;
 202
 203     for (long x = midX + 1; x <= lastX - 1; x++)
 204     {
 205         checkValue(pAccess, x, midY - offsetFromMid, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
 206         checkValue(pAccess, x, midY + offsetFromMid, aExpectedColor, nNumberOfQuirks, nNumberOfErrors, false);
 207
 208         offsetFromMid--;
 209     }
 210
 211     if (nNumberOfQuirks > 0)
 212         aResult = TestResult::PassedWithQuirks;
 213     if (nNumberOfErrors > 0)
 214         aResult = TestResult::Failed;
 215     return aResult;
 216 }
 217
 218 } // end anonymous namespace
 219
 220 const Color OutputDeviceTestCommon::constBackgroundColor(COL_LIGHTGRAY);
 221 const Color OutputDeviceTestCommon::constLineColor(COL_LIGHTBLUE);
 222 const Color OutputDeviceTestCommon::constFillColor(COL_LIGHTBLUE);
 223
 224 OutputDeviceTestCommon::OutputDeviceTestCommon()
 225     : mpVirtualDevice(VclPtr<VirtualDevice>::Create())
 226 {}
 227
 228 void OutputDeviceTestCommon::initialSetup(long nWidth, long nHeight, Color aColor, bool bEnableAA)
 229 {
 230     maVDRectangle = tools::Rectangle(Point(), Size (nWidth, nHeight));
 231     mpVirtualDevice->SetOutputSizePixel(maVDRectangle.GetSize());
 232     if (bEnableAA)
 233         mpVirtualDevice->SetAntialiasing(AntialiasingFlags::EnableB2dDraw | AntialiasingFlags::PixelSnapHairline);
 234     else
 235         mpVirtualDevice->SetAntialiasing(AntialiasingFlags::NONE);
 236     mpVirtualDevice->SetBackground(Wallpaper(aColor));
 237     mpVirtualDevice->Erase();
 238 }
 239
 240 TestResult OutputDeviceTestCommon::checkLines(Bitmap& rBitmap)
 241 {
 242     return checkHorizontalVerticalDiagonalLines(rBitmap, constLineColor, 0);
 243 }
 244
 245 TestResult OutputDeviceTestCommon::checkAALines(Bitmap& rBitmap)
 246 {
 247     return checkHorizontalVerticalDiagonalLines(rBitmap, constLineColor, 30); // 30 color values threshold delta
 248 }
 249
 250 TestResult OutputDeviceTestCommon::checkRectangle(Bitmap& aBitmap)
 251 {
 252     std::vector<Color> aExpected
 253     {
 254         constBackgroundColor, constBackgroundColor, constLineColor,
 255         constBackgroundColor, constBackgroundColor, constLineColor, constBackgroundColor
 256     };
 257     return checkRectangles(aBitmap, aExpected);
 258 }
 259
 260 TestResult OutputDeviceTestCommon::checkRectangleAA(Bitmap& aBitmap)
 261 {
 262     std::vector<Color> aExpected
 263     {
 264         constBackgroundColor, constBackgroundColor, constLineColor,
 265         constBackgroundColor, constBackgroundColor, constLineColor, constBackgroundColor
 266     };
 267     return checkRectangles(aBitmap, aExpected);
 268 }
 269
 270 TestResult OutputDeviceTestCommon::checkFilledRectangle(Bitmap& aBitmap)
 271 {
 272     std::vector<Color> aExpected
 273     {
 274         constBackgroundColor, constBackgroundColor,
 275         constFillColor, constFillColor, constFillColor, constFillColor, constFillColor
 276     };
 277     return checkRectangles(aBitmap, aExpected);
 278 }
 279
 280 TestResult OutputDeviceTestCommon::checkRectangles(Bitmap& aBitmap, std::vector<Color>& aExpectedColors)
 281 {
 282     TestResult aReturnValue = TestResult::Passed;
 283     for (size_t i = 0; i < aExpectedColors.size(); i++)
 284     {
 285         switch(checkRect(aBitmap, i, aExpectedColors[i]))
 286         {
 287             case TestResult::Failed:
 288                 return TestResult::Failed;
 289             case TestResult::PassedWithQuirks:
 290                 aReturnValue = TestResult::PassedWithQuirks;
 291                 break;
 292             default:
 293                 break;
 294         }
 295
 296     }
 297     return aReturnValue;
 298 }
 299
 300 tools::Rectangle OutputDeviceTestCommon::alignToCenter(tools::Rectangle aRect1, tools::Rectangle aRect2)
 301 {
 302     Point aPoint((aRect1.GetWidth()  / 2.0) - (aRect2.GetWidth()  / 2.0),
 303                  (aRect1.GetHeight() / 2.0) - (aRect2.GetHeight() / 2.0));
 304
 305     return tools::Rectangle(aPoint, aRect2.GetSize());
 306 }
 307
 308 TestResult OutputDeviceTestCommon::checkDiamond(Bitmap& rBitmap)
 309 {
 310     return checkDiamondLine(rBitmap, 1, constLineColor);
 311 }
 312
 313 void OutputDeviceTestCommon::createDiamondPoints(tools::Rectangle rRect, int nOffset,
 314                                                  Point& rPoint1, Point& rPoint2,
 315                                                  Point& rPoint3, Point& rPoint4)
 316 {
 317     long midPointX = rRect.Left() + (rRect.Right()  - rRect.Left()) / 2.0;
 318     long midPointY = rRect.Top()  + (rRect.Bottom() - rRect.Top())  / 2.0;
 319
 320     rPoint1 = Point(midPointX         , midPointY - nOffset);
 321     rPoint2 = Point(midPointX + nOffset, midPointY         );
 322     rPoint3 = Point(midPointX         , midPointY + nOffset);
 323     rPoint4 = Point(midPointX - nOffset, midPointY         );
 324 }
 325
 326 void OutputDeviceTestCommon::createHorizontalVerticalDiagonalLinePoints(tools::Rectangle rRect,
 327                                 Point& rHorizontalLinePoint1, Point& rHorizontalLinePoint2,
 328                                 Point& rVerticalLinePoint1, Point& rVerticalLinePoint2,
 329                                 Point& rDiagonalLinePoint1, Point& rDiagonalLinePoint2)
 330 {
 331     rHorizontalLinePoint1 = Point(4, 1);
 332     rHorizontalLinePoint2 = Point(rRect.Right() - 1, 1);
 333
 334     rVerticalLinePoint1 = Point(1, 4);
 335     rVerticalLinePoint2 = Point(1,rRect.Bottom() - 1);
 336
 337     rDiagonalLinePoint1 = Point(1, 1);
 338     rDiagonalLinePoint2 = Point(rRect.Right() - 1, rRect.Bottom() - 1);
 339 }
 340
 341 }} // end namespace vcl::test
 342
 343 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */