40 std::shared_ptr<SalBitmap> xImpBmp(
ImplGetSVData()->mpDefInst->CreateSalBitmap());
41 if (xImpBmp->Create(*
mxSalBmp) && xImpBmp->Erase(rFillColor))
54 pWriteAcc->Erase(rFillColor);
68 if (pAcc->HasPalette())
78 pAcc->SetPalette(aBmpPal);
87 Scanline pScanline = pAcc->GetScanline(nY);
90 BitmapColor aBmpColor = pAcc->GetPixelFromData(pScanline, nX);
92 pAcc->SetPixelOnData(pScanline, nX, aBmpColor);
109template <
int bitCount>
112 constexpr int byteCount = bitCount / 8;
114 Scanline pos2 = scanline2 + (nWidth - 1) * byteCount;
118 memcpy(tmp, pos1, byteCount);
119 memcpy(pos1, pos2, byteCount);
120 memcpy(pos2, tmp, byteCount);
145 switch (pAcc->GetBitCount())
150 mirrorScanlines<32>(pAcc->GetScanline(nY),
151 pAcc->GetScanline(nY) + 4 * nSecondHalf, nWidth_2);
155 mirrorScanlines<24>(pAcc->GetScanline(nY),
156 pAcc->GetScanline(nY) + 3 * nSecondHalf, nWidth_2);
160 mirrorScanlines<8>(pAcc->GetScanline(nY),
161 pAcc->GetScanline(nY) + nSecondHalf, nWidth_2);
166 Scanline pScanline = pAcc->GetScanline(nY);
167 for (
tools::Long nX = 0, nOther = nWidth1; nX < nWidth_2; nX++, nOther--)
169 const BitmapColor aTemp(pAcc->GetPixelFromData(pScanline, nX));
171 pAcc->SetPixelOnData(pScanline, nX,
172 pAcc->GetPixelFromData(pScanline, nOther));
173 pAcc->SetPixelOnData(pScanline, nOther, aTemp);
182 else if (bVert && !bHorz)
188 const tools::Long nScanSize = pAcc->GetScanlineSize();
189 std::unique_ptr<sal_uInt8[]> pBuffer(
new sal_uInt8[nScanSize]);
194 for (
tools::Long nY = 0, nOther = nHeight1; nY < nHeight_2; nY++, nOther--)
196 memcpy(pBuffer.get(), pAcc->GetScanline(nY), nScanSize);
197 memcpy(pAcc->GetScanline(nY), pAcc->GetScanline(nOther), nScanSize);
198 memcpy(pAcc->GetScanline(nOther), pBuffer.
get(), nScanSize);
205 else if (bHorz && bVert)
218 switch (pAcc->GetBitCount())
221 for (
tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
222 mirrorScanlines<32>(pAcc->GetScanline(nY), pAcc->GetScanline(nOtherY),
225 mirrorScanlines<32>(pAcc->GetScanline(nHeight_2),
226 pAcc->GetScanline(nHeight_2) + 4 * nSecondHalf,
230 for (
tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
231 mirrorScanlines<24>(pAcc->GetScanline(nY), pAcc->GetScanline(nOtherY),
234 mirrorScanlines<24>(pAcc->GetScanline(nHeight_2),
235 pAcc->GetScanline(nHeight_2) + 3 * nSecondHalf,
239 for (
tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
240 mirrorScanlines<8>(pAcc->GetScanline(nY), pAcc->GetScanline(nOtherY),
243 mirrorScanlines<8>(pAcc->GetScanline(nHeight_2),
244 pAcc->GetScanline(nHeight_2) + nSecondHalf, nWidth_2);
247 for (
tools::Long nY = 0, nOtherY = nHeight - 1; nY < nHeight_2; nY++, nOtherY--)
249 Scanline pScanline = pAcc->GetScanline(nY);
250 Scanline pScanlineOther = pAcc->GetScanline(nOtherY);
251 for (
tools::Long nX = 0, nOtherX = nWidth1; nX < nWidth; nX++, nOtherX--)
253 const BitmapColor aTemp(pAcc->GetPixelFromData(pScanline, nX));
255 pAcc->SetPixelOnData(pScanline, nX,
256 pAcc->GetPixelFromData(pScanlineOther, nOtherX));
257 pAcc->SetPixelOnData(pScanlineOther, nOtherX, aTemp);
264 Scanline pScanline = pAcc->GetScanline(nHeight_2);
265 for (
tools::Long nX = 0, nOtherX = nWidth1; nX < nWidth_2; nX++, nOtherX--)
267 const BitmapColor aTemp(pAcc->GetPixelFromData(pScanline, nX));
268 pAcc->SetPixelOnData(pScanline, nX,
269 pAcc->GetPixelFromData(pScanline, nOtherX));
270 pAcc->SetPixelOnData(pScanline, nOtherX, aTemp);
289 nAngle10 %= 3600_deg10;
290 nAngle10 = (nAngle10 < 0_deg10) ? (
Degree10(3599) + nAngle10) : nAngle10;
294 else if (nAngle10 == 1800_deg10)
305 if (nAngle10 == 900_deg10 || nAngle10 == 2700_deg10)
320 if (nAngle10 == 900_deg10)
322 for (
tools::Long nY = 0, nOtherX = nWidth1; nY < nNewHeight;
325 Scanline pScanline = pWriteAcc->GetScanline(nY);
326 for (
tools::Long nX = 0, nOtherY = 0; nX < nNewWidth; nX++)
328 pWriteAcc->SetPixelOnData(pScanline, nX,
329 pReadAcc->
GetPixel(nOtherY++, nOtherX));
333 else if (nAngle10 == 2700_deg10)
335 for (
tools::Long nY = 0, nOtherX = 0; nY < nNewHeight; nY++, nOtherX++)
337 Scanline pScanline = pWriteAcc->GetScanline(nY);
338 for (
tools::Long nX = 0, nOtherY = nHeight1; nX < nNewWidth; nX++)
340 pWriteAcc->SetPixelOnData(pScanline, nX,
341 pReadAcc->
GetPixel(nOtherY--, nOtherX));
349 aRotatedBmp = aNewBmp;
356 aPoly.
Rotate(aTmpPoint, nAngle10);
365 const BitmapColor aFillColor(pWriteAcc->GetBestMatchingColor(rFillColor));
366 const double fCosAngle = cos(
toRadians(nAngle10));
367 const double fSinAngle = sin(
toRadians(nAngle10));
368 const double fXMin = aNewBound.
Left();
369 const double fYMin = aNewBound.
Top();
370 const sal_Int32 nWidth = aSizePix.
Width();
371 const sal_Int32 nHeight = aSizePix.
Height();
372 const sal_Int32 nNewWidth = aNewSizePix.
Width();
373 const sal_Int32 nNewHeight = aNewSizePix.
Height();
376 std::unique_ptr<sal_Int32[]> pCosSinX(
new sal_Int32[nNewWidth * 2]);
377 std::unique_ptr<sal_Int32[]> pCosSinY(
new sal_Int32[nNewHeight * 2]);
379 for (sal_Int32 nIdx = 0, nX = 0; nX < nNewWidth; nX++)
381 const double fTmp = (fXMin + nX) * 64;
383 pCosSinX[nIdx++] = std::round(fCosAngle * fTmp);
384 pCosSinX[nIdx++] = std::round(fSinAngle * fTmp);
387 for (sal_Int32 nIdx = 0, nY = 0; nY < nNewHeight; nY++)
389 const double fTmp = (fYMin + nY) * 64;
391 pCosSinY[nIdx++] = std::round(fCosAngle * fTmp);
392 pCosSinY[nIdx++] = std::round(fSinAngle * fTmp);
395 for (sal_Int32 nCosSinYIdx = 0, nY = 0; nY < nNewHeight; nY++)
397 sal_Int32 nCosY = pCosSinY[nCosSinYIdx++];
398 sal_Int32 nSinY = pCosSinY[nCosSinYIdx++];
399 Scanline pScanline = pWriteAcc->GetScanline(nY);
401 for (sal_Int32 nCosSinXIdx = 0, nX = 0; nX < nNewWidth; nX++)
403 sal_Int32 nRotX = (pCosSinX[nCosSinXIdx++] - nSinY) >> 6;
404 sal_Int32 nRotY = (pCosSinX[nCosSinXIdx++] + nCosY) >> 6;
406 if ((nRotX > -1) && (nRotX < nWidth) && (nRotY > -1)
407 && (nRotY < nHeight))
409 pWriteAcc->SetPixelOnData(pScanline, nX,
414 pWriteAcc->SetPixelOnData(pScanline, nX, aFillColor);
422 aRotatedBmp = aNewBmp;
444 constexpr bool use8BitMask =
true;
446 if (!nTol && pReadAcc
462 if (pWriteAcc && pReadAcc)
473 if (pWriteAcc->GetBitCount() == 1
486 Scanline pDst = pWriteAcc->GetScanline(nY);
489 if (cTest == pSrc[nX])
490 pDst[nX >> 3] |= 1 << (7 - (nX & 7));
492 pDst[nX >> 3] &= ~(1 << (7 - (nX & 7)));
501 Scanline pDst = pWriteAcc->GetScanline(nY);
504 if (cTest == pSrc[nX])
505 pWriteAcc->SetPixelOnData(pDst, nX, aWhite);
507 pWriteAcc->SetPixelOnData(pDst, nX, aBlack);
520 Scanline pDst = pWriteAcc->GetScanline(nY);
522 const tools::Long nScanlineSize = pWriteAcc->GetScanlineSize();
524 pDst[nX] = ~pSrc[nX];
527 else if (use8BitMask && pWriteAcc->GetBitCount() == 8
536 Scanline pDst = pWriteAcc->GetScanline(nY);
539 if (cTest == pSrc[nX])
551 Scanline pScanline = pWriteAcc->GetScanline(nY);
556 pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
558 pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
567 const tools::Long nMinR = MinMax<tools::Long>(rTransColor.
GetRed() - nTol, 0, 255);
568 const tools::Long nMaxR = MinMax<tools::Long>(rTransColor.
GetRed() + nTol, 0, 255);
578 Scanline pScanline = pWriteAcc->GetScanline(nY);
588 if (nMinR <= nR && nMaxR >= nR && nMinG <= nG && nMaxG >= nG && nMinB <= nB
591 pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
595 pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
604 Scanline pScanline = pWriteAcc->GetScanline(nY);
613 if (nMinR <= nR && nMaxR >= nR && nMinG <= nG && nMaxG >= nG && nMinB <= nB
616 pWriteAcc->SetPixelOnData(pScanline, nX, aWhite);
620 pWriteAcc->SetPixelOnData(pScanline, nX, aBlack);
661 std::vector<tools::Long> aLine;
665 for (; nY <= nBottom; nY++)
667 std::vector<tools::Long> aNewLine;
671 for (; nX <= nRight;)
673 while ((nX <= nRight) && (aMatch != pReadAcc->
GetPixelFromData(pScanlineRead, nX)))
678 aNewLine.push_back(nX);
680 while ((nX <= nRight)
686 aNewLine.push_back(nX - 1);
690 if (aNewLine != aLine)
701 for (
size_t a(0);
a < aLine.size();)
705 aRegion.
Union(aSubRect);
724 for (
size_t a(0);
a < aLine.size();)
728 aRegion.
Union(aSubRect);
748 if (pMaskAcc && pAcc)
755 if (pAcc->HasPalette())
757 const sal_uInt16 nActColors = pAcc->GetPaletteEntryCount();
758 const sal_uInt16 nMaxColors = 1 << pAcc->GetBitCount();
761 aReplace = pAcc->GetBestMatchingColor(rReplaceColor);
768 if (nActColors < nMaxColors)
770 pAcc->SetPaletteEntryCount(nActColors + 1);
771 pAcc->SetPaletteColor(nActColors, rReplaceColor);
776 std::unique_ptr<bool[]> pFlags(
new bool[nMaxColors]);
779 std::fill(pFlags.get(), pFlags.get() + nMaxColors,
false);
783 Scanline pScanline = pAcc->GetScanline(nY);
785 pFlags[pAcc->GetIndexFromData(pScanline, nX)] =
true;
788 for (sal_uInt16
i = 0;
i < nMaxColors;
i++)
793 pAcc->SetPaletteColor(
i, rReplaceColor);
801 aReplace = rReplaceColor;
805 Scanline pScanline = pAcc->GetScanline(nY);
810 pAcc->SetPixelOnData(pScanline, nX, aReplace);
828 if (pAcc && pAlphaAcc && pNewAcc)
836 Scanline pScanline = pNewAcc->GetScanline(nY);
837 Scanline pScanlineAlpha = pAlphaAcc->GetScanline(nY);
841 aCol.
Merge(rMergeColor, 255 - pAlphaAcc->GetIndexFromData(pScanlineAlpha, nX));
842 pNewAcc->SetPixelOnData(pScanline, nX, aCol);
872 std::shared_ptr<SalBitmap> xImpBmp(
ImplGetSVData()->mpDefInst->CreateSalBitmap());
873 if (xImpBmp->Create(*
mxSalBmp) && xImpBmp->Replace(rSearchColor, rReplaceColor, nTol))
892 const tools::Long nMinR = MinMax<tools::Long>(rSearchColor.
GetRed() - nTol, 0, 255);
893 const tools::Long nMaxR = MinMax<tools::Long>(rSearchColor.
GetRed() + nTol, 0, 255);
899 if (pAcc->HasPalette())
901 for (sal_uInt16
i = 0, nPalCount = pAcc->GetPaletteEntryCount();
i < nPalCount;
i++)
909 pAcc->SetPaletteColor(
i, rReplaceColor);
916 const BitmapColor aReplace(pAcc->GetBestMatchingColor(rReplaceColor));
918 for (
tools::Long nY = 0, nHeight = pAcc->Height(); nY < nHeight; nY++)
920 Scanline pScanline = pAcc->GetScanline(nY);
921 for (
tools::Long nX = 0, nWidth = pAcc->Width(); nX < nWidth; nX++)
923 aCol = pAcc->GetPixelFromData(pScanline, nX);
929 pAcc->SetPixelOnData(pScanline, nX, aReplace);
955 std::vector<sal_uInt8> aMinR(nColorCount);
956 std::vector<sal_uInt8> aMaxR(nColorCount);
957 std::vector<sal_uInt8> aMinG(nColorCount);
958 std::vector<sal_uInt8> aMaxG(nColorCount);
959 std::vector<sal_uInt8> aMinB(nColorCount);
960 std::vector<sal_uInt8> aMaxB(nColorCount);
964 for (
size_t i = 0;
i < nColorCount; ++
i)
966 const Color& rCol = pSearchColors[
i];
969 aMinR[
i] = std::clamp(rCol.
GetRed() - nTol, 0, 255);
970 aMaxR[
i] = std::clamp(rCol.
GetRed() + nTol, 0, 255);
971 aMinG[
i] = std::clamp(rCol.
GetGreen() - nTol, 0, 255);
972 aMaxG[
i] = std::clamp(rCol.
GetGreen() + nTol, 0, 255);
973 aMinB[
i] = std::clamp(rCol.
GetBlue() - nTol, 0, 255);
974 aMaxB[
i] = std::clamp(rCol.
GetBlue() + nTol, 0, 255);
979 for (
size_t i = 0;
i < nColorCount; ++
i)
981 const Color& rCol = pSearchColors[
i];
992 if (pAcc->HasPalette())
994 for (sal_uInt16 nEntry = 0, nPalCount = pAcc->GetPaletteEntryCount();
995 nEntry < nPalCount; nEntry++)
997 const BitmapColor& rCol = pAcc->GetPaletteColor(nEntry);
999 for (
size_t i = 0;
i < nColorCount; ++
i)
1005 pAcc->SetPaletteColor(nEntry, pReplaceColors[
i]);
1013 std::vector<BitmapColor> aReplaces(nColorCount);
1015 for (
size_t i = 0;
i < nColorCount; ++
i)
1016 aReplaces[
i] = pAcc->GetBestMatchingColor(pReplaceColors[
i]);
1018 for (
tools::Long nY = 0, nHeight = pAcc->Height(); nY < nHeight; nY++)
1020 Scanline pScanline = pAcc->GetScanline(nY);
1021 for (
tools::Long nX = 0, nWidth = pAcc->Width(); nX < nWidth; nX++)
1023 BitmapColor aCol = pAcc->GetPixelFromData(pScanline, nX);
1025 for (
size_t i = 0;
i < nColorCount; ++
i)
1031 pAcc->SetPixelOnData(pScanline, nX, aReplaces[
i]);
1052 if (pMaskAcc && pAcc)
1058 const BitmapColor aBlack(pAcc->GetBestMatchingColor(aColBlack));
1063 Scanline pScanline = pAcc->GetScanline(nY);
1068 || pAcc->GetPixelFromData(pScanline, nX) != aBlack)
1070 pAcc->SetPixelOnData(pScanline, nX, aWhite);
1074 pAcc->SetPixelOnData(pScanline, nX, aBlack);
1099 if (pAlphaAcc && pAcc)
1101 const tools::Long nWidth = std::min(pAlphaAcc->Width(), pAcc->Width());
1102 const tools::Long nHeight = std::min(pAlphaAcc->Height(), pAcc->Height());
1106 Scanline pScanline = pAcc->GetScanline(nY);
1107 Scanline pScanlineAlpha = pAlphaAcc->GetScanline(nY);
1110 BitmapColor aBmpColor = pAcc->GetPixelFromData(pScanline, nX);
1111 aBmpColor.
Merge(rBackgroundColor,
1112 255 - pAlphaAcc->GetIndexFromData(pScanlineAlpha, nX));
1113 pAcc->SetPixelOnData(pScanline, nX, aBmpColor);
sal_uInt8 GetIndex() const
tools::Long Height() const
tools::Long Width() const
const BitmapPalette & GetPalette() const
BitmapColor GetBestMatchingColor(const BitmapColor &rBitmapColor) const
ScanlineFormat GetScanlineFormat() const
const BitmapColor & GetPaletteColor(sal_uInt16 nColor) const
sal_uInt32 GetScanlineSize() const
sal_uInt16 GetEntryCount() const
BitmapColor GetPixel(tools::Long nY, tools::Long nX) const
BitmapColor GetColor(tools::Long nY, tools::Long nX) const
BitmapColor GetPixelFromData(const sal_uInt8 *pData, tools::Long nX) const
sal_uInt8 GetIndexFromData(const sal_uInt8 *pData, tools::Long nX) const
Scanline GetScanline(tools::Long nY) const
bool CombineOr(const Bitmap &rMask)
Perform boolean OR operation with another bitmap.
bool Blend(const AlphaMask &rAlpha, const Color &rBackgroundColor)
Alpha-blend the given bitmap against a specified uniform background color.
Bitmap CreateMask(const Color &rTransColor, sal_uInt8 nTol=0) const
Create on-off mask from bitmap.
bool Rotate(Degree10 nAngle10, const Color &rFillColor)
Rotate bitmap by the specified angle.
SAL_DLLPRIVATE void ImplSetSalBitmap(const std::shared_ptr< SalBitmap > &xImpBmp)
bool Convert(BmpConversion eConversion)
Convert bitmap format.
static const BitmapPalette & GetGreyPalette(int nEntries)
SAL_DLLPRIVATE void ReassignWithSize(const Bitmap &rBitmap)
ReassignWithSize and recalculate bitmap.
Size GetSizePixel() const
bool Invert()
Perform the Invert operation on every pixel.
vcl::Region CreateRegion(const Color &rColor, const tools::Rectangle &rRect) const
Create region of similar colors in a given rectangle.
bool Erase(const Color &rFillColor)
Fill the entire bitmap with the given color.
bool Replace(const Bitmap &rMask, const Color &rReplaceColor)
Replace all pixel where the given mask is on with the specified color.
vcl::PixelFormat getPixelFormat() const
std::shared_ptr< SalBitmap > mxSalBmp
bool Mirror(BmpMirrorFlags nMirrorFlags)
Mirror the bitmap.
sal_uInt8 GetBlue() const
void Merge(const Color &rMergeColor, sal_uInt8 cTransparency)
sal_uInt8 GetGreen() const
constexpr tools::Long Height() const
constexpr tools::Long Width() const
void Union(const tools::Rectangle &rRegion)
This template handles BitmapAccess the RAII way.
constexpr ::Color COL_WHITE(0xFF, 0xFF, 0xFF)
constexpr ::Color COL_BLACK(0x00, 0x00, 0x00)
constexpr bool isPalettePixelFormat(PixelFormat ePixelFormat)
Is it a pixel format that forces creation of a palette.
HashMap_OWString_Interface aMap
ImplSVData * ImplGetSVData()