juce/source/src/gui/graphics/imaging/juce_Image.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_Image.h"
  31 #include "../contexts/juce_Graphics.h"
  32 #include "../contexts/juce_LowLevelGraphicsSoftwareRenderer.h"
  33 #include "../colour/juce_PixelFormats.h"
  34 #include "../../../containers/juce_SparseSet.h"
  35
  36
  37 //==============================================================================
  38 Image::SharedImage::SharedImage (const PixelFormat format_, const int width_, const int height_)
  39     : format (format_), width (width_), height (height_)
  40 {
  41     jassert (format_ == RGB || format_ == ARGB || format_ == SingleChannel);
  42     jassert (width > 0 && height > 0); // It's illegal to create a zero-sized image!
  43 }
  44
  45 Image::SharedImage::~SharedImage()
  46 {
  47 }
  48
  49 //==============================================================================
  50 class SoftwareSharedImage  : public Image::SharedImage
  51 {
  52 public:
  53     SoftwareSharedImage (const Image::PixelFormat format_, const int width_, const int height_, const bool clearImage)
  54         : Image::SharedImage (format_, width_, height_),
  55           pixelStride (format_ == Image::RGB ? 3 : ((format_ == Image::ARGB) ? 4 : 1)),
  56           lineStride ((pixelStride * jmax (1, width_) + 3) & ~3)
  57     {
  58         imageData.allocate (lineStride * jmax (1, height_), clearImage);
  59     }
  60
  61     Image::ImageType getType() const
  62     {
  63         return Image::SoftwareImage;
  64     }
  65
  66     LowLevelGraphicsContext* createLowLevelContext()
  67     {
  68         return new LowLevelGraphicsSoftwareRenderer (Image (this));
  69     }
  70
  71     void initialiseBitmapData (Image::BitmapData& bitmap, int x, int y, Image::BitmapData::ReadWriteMode /*mode*/)
  72     {
  73         bitmap.data = imageData + x * pixelStride + y * lineStride;
  74         bitmap.pixelFormat = format;
  75         bitmap.lineStride = lineStride;
  76         bitmap.pixelStride = pixelStride;
  77     }
  78
  79     Image::SharedImage* clone()
  80     {
  81         SoftwareSharedImage* s = new SoftwareSharedImage (format, width, height, false);
  82         memcpy (s->imageData, imageData, lineStride * height);
  83         return s;
  84     }
  85
  86 private:
  87     HeapBlock<uint8> imageData;
  88     const int pixelStride, lineStride;
  89
  90     JUCE_LEAK_DETECTOR (SoftwareSharedImage);
  91 };
  92
  93 Image::SharedImage* Image::SharedImage::createSoftwareImage (Image::PixelFormat format, int width, int height, bool clearImage)
  94 {
  95     return new SoftwareSharedImage (format, width, height, clearImage);
  96 }
  97
  98 //==============================================================================
  99 class SubsectionSharedImage  : public Image::SharedImage
 100 {
 101 public:
 102     SubsectionSharedImage (Image::SharedImage* const image_, const Rectangle<int>& area_)
 103         : Image::SharedImage (image_->getPixelFormat(), area_.getWidth(), area_.getHeight()),
 104           image (image_), area (area_)
 105     {
 106     }
 107
 108     Image::ImageType getType() const
 109     {
 110         return Image::SoftwareImage;
 111     }
 112
 113     LowLevelGraphicsContext* createLowLevelContext()
 114     {
 115         LowLevelGraphicsContext* g = image->createLowLevelContext();
 116         g->clipToRectangle (area);
 117         g->setOrigin (area.getX(), area.getY());
 118         return g;
 119     }
 120
 121     void initialiseBitmapData (Image::BitmapData& bitmap, int x, int y, Image::BitmapData::ReadWriteMode mode)
 122     {
 123         image->initialiseBitmapData (bitmap, x + area.getX(), y + area.getY(), mode);
 124     }
 125
 126     Image::SharedImage* clone()
 127     {
 128         return new SubsectionSharedImage (image->clone(), area);
 129     }
 130
 131 private:
 132     const ReferenceCountedObjectPtr<Image::SharedImage> image;
 133     const Rectangle<int> area;
 134
 135     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SubsectionSharedImage);
 136 };
 137
 138 Image Image::getClippedImage (const Rectangle<int>& area) const
 139 {
 140     if (area.contains (getBounds()))
 141         return *this;
 142
 143     const Rectangle<int> validArea (area.getIntersection (getBounds()));
 144     if (validArea.isEmpty())
 145         return Image::null;
 146
 147     return Image (new SubsectionSharedImage (image, validArea));
 148 }
 149
 150
 151 //==============================================================================
 152 Image::Image()
 153 {
 154 }
 155
 156 Image::Image (SharedImage* const instance)
 157     : image (instance)
 158 {
 159 }
 160
 161 Image::Image (const PixelFormat format,
 162               const int width, const int height,
 163               const bool clearImage, const ImageType type)
 164     : image (type == Image::NativeImage ? SharedImage::createNativeImage (format, width, height, clearImage)
 165                                         : new SoftwareSharedImage (format, width, height, clearImage))
 166 {
 167 }
 168
 169 Image::Image (const Image& other)
 170    : image (other.image)
 171 {
 172 }
 173
 174 Image& Image::operator= (const Image& other)
 175 {
 176     image = other.image;
 177     return *this;
 178 }
 179
 180 Image::~Image()
 181 {
 182 }
 183
 184 const Image Image::null;
 185
 186 LowLevelGraphicsContext* Image::createLowLevelContext() const
 187 {
 188     return image == nullptr ? nullptr : image->createLowLevelContext();
 189 }
 190
 191 void Image::duplicateIfShared()
 192 {
 193     if (image != nullptr && image->getReferenceCount() > 1)
 194         image = image->clone();
 195 }
 196
 197 Image Image::rescaled (const int newWidth, const int newHeight, const Graphics::ResamplingQuality quality) const
 198 {
 199     if (image == nullptr || (image->width == newWidth && image->height == newHeight))
 200         return *this;
 201
 202     Image newImage (image->format, newWidth, newHeight, hasAlphaChannel(), image->getType());
 203
 204     Graphics g (newImage);
 205     g.setImageResamplingQuality (quality);
 206     g.drawImage (*this, 0, 0, newWidth, newHeight, 0, 0, image->width, image->height, false);
 207
 208     return newImage;
 209 }
 210
 211 Image Image::convertedToFormat (PixelFormat newFormat) const
 212 {
 213     if (image == nullptr || newFormat == image->format)
 214         return *this;
 215
 216     const int w = image->width, h = image->height;
 217     Image newImage (newFormat, w, h, false, image->getType());
 218
 219     if (newFormat == SingleChannel)
 220     {
 221         if (! hasAlphaChannel())
 222         {
 223             newImage.clear (getBounds(), Colours::black);
 224         }
 225         else
 226         {
 227             const BitmapData destData (newImage, 0, 0, w, h, BitmapData::writeOnly);
 228             const BitmapData srcData (*this, 0, 0, w, h);
 229
 230             for (int y = 0; y < h; ++y)
 231             {
 232                 const PixelARGB* src = (const PixelARGB*) srcData.getLinePointer(y);
 233                 uint8* dst = destData.getLinePointer (y);
 234
 235                 for (int x = w; --x >= 0;)
 236                 {
 237                     *dst++ = src->getAlpha();
 238                     ++src;
 239                 }
 240             }
 241         }
 242     }
 243     else
 244     {
 245         if (hasAlphaChannel())
 246             newImage.clear (getBounds());
 247
 248         Graphics g (newImage);
 249         g.drawImageAt (*this, 0, 0);
 250     }
 251
 252     return newImage;
 253 }
 254
 255 NamedValueSet* Image::getProperties() const
 256 {
 257     return image == nullptr ? nullptr : &(image->userData);
 258 }
 259
 260 //==============================================================================
 261 Image::BitmapData::BitmapData (Image& image, const int x, const int y, const int w, const int h, BitmapData::ReadWriteMode mode)
 262     : width (w),
 263       height (h)
 264 {
 265     // The BitmapData class must be given a valid image, and a valid rectangle within it!
 266     jassert (image.image != nullptr);
 267     jassert (x >= 0 && y >= 0 && w > 0 && h > 0 && x + w <= image.getWidth() && y + h <= image.getHeight());
 268
 269     image.image->initialiseBitmapData (*this, x, y, mode);
 270     jassert (data != nullptr && pixelStride > 0 && lineStride != 0);
 271 }
 272
 273 Image::BitmapData::BitmapData (const Image& image, const int x, const int y, const int w, const int h)
 274     : width (w),
 275       height (h)
 276 {
 277     // The BitmapData class must be given a valid image, and a valid rectangle within it!
 278     jassert (image.image != nullptr);
 279     jassert (x >= 0 && y >= 0 && w > 0 && h > 0 && x + w <= image.getWidth() && y + h <= image.getHeight());
 280
 281     image.image->initialiseBitmapData (*this, x, y, readOnly);
 282     jassert (data != nullptr && pixelStride > 0 && lineStride != 0);
 283 }
 284
 285 Image::BitmapData::BitmapData (const Image& image, BitmapData::ReadWriteMode mode)
 286     : width (image.getWidth()),
 287       height (image.getHeight())
 288 {
 289     // The BitmapData class must be given a valid image!
 290     jassert (image.image != nullptr);
 291
 292     image.image->initialiseBitmapData (*this, 0, 0, mode);
 293     jassert (data != nullptr && pixelStride > 0 && lineStride != 0);
 294 }
 295
 296 Image::BitmapData::~BitmapData()
 297 {
 298 }
 299
 300 const Colour Image::BitmapData::getPixelColour (const int x, const int y) const noexcept
 301 {
 302     jassert (isPositiveAndBelow (x, width) && isPositiveAndBelow (y, height));
 303
 304     const uint8* const pixel = getPixelPointer (x, y);
 305
 306     switch (pixelFormat)
 307     {
 308         case Image::ARGB:           return Colour (((const PixelARGB*) pixel)->getUnpremultipliedARGB());
 309         case Image::RGB:            return Colour (((const PixelRGB*) pixel)->getUnpremultipliedARGB());
 310         case Image::SingleChannel:  return Colour (((const PixelAlpha*) pixel)->getUnpremultipliedARGB());
 311         default:                    jassertfalse; break;
 312     }
 313
 314     return Colour();
 315 }
 316
 317 void Image::BitmapData::setPixelColour (const int x, const int y, const Colour& colour) const noexcept
 318 {
 319     jassert (isPositiveAndBelow (x, width) && isPositiveAndBelow (y, height));
 320
 321     uint8* const pixel = getPixelPointer (x, y);
 322     const PixelARGB col (colour.getPixelARGB());
 323
 324     switch (pixelFormat)
 325     {
 326         case Image::ARGB:           ((PixelARGB*) pixel)->set (col); break;
 327         case Image::RGB:            ((PixelRGB*) pixel)->set (col); break;
 328         case Image::SingleChannel:  *pixel = col.getAlpha(); break;
 329         default:                    jassertfalse; break;
 330     }
 331 }
 332
 333 void Image::setPixelData (int x, int y, int w, int h,
 334                           const uint8* const sourcePixelData, const int sourceLineStride)
 335 {
 336     jassert (x >= 0 && y >= 0 && w > 0 && h > 0 && x + w <= getWidth() && y + h <= getHeight());
 337
 338     if (Rectangle<int>::intersectRectangles (x, y, w, h, 0, 0, getWidth(), getHeight()))
 339     {
 340         const BitmapData dest (*this, x, y, w, h, BitmapData::writeOnly);
 341
 342         for (int i = 0; i < h; ++i)
 343         {
 344             memcpy (dest.getLinePointer(i),
 345                     sourcePixelData + sourceLineStride * i,
 346                     w * dest.pixelStride);
 347         }
 348     }
 349 }
 350
 351 //==============================================================================
 352 void Image::clear (const Rectangle<int>& area, const Colour& colourToClearTo)
 353 {
 354     const Rectangle<int> clipped (area.getIntersection (getBounds()));
 355
 356     if (! clipped.isEmpty())
 357     {
 358         const PixelARGB col (colourToClearTo.getPixelARGB());
 359
 360         const BitmapData destData (*this, clipped.getX(), clipped.getY(), clipped.getWidth(), clipped.getHeight(), BitmapData::writeOnly);
 361         uint8* dest = destData.data;
 362         int dh = clipped.getHeight();
 363
 364         while (--dh >= 0)
 365         {
 366             uint8* line = dest;
 367             dest += destData.lineStride;
 368
 369             if (isARGB())
 370             {
 371                 for (int x = clipped.getWidth(); --x >= 0;)
 372                 {
 373                     ((PixelARGB*) line)->set (col);
 374                     line += destData.pixelStride;
 375                 }
 376             }
 377             else if (isRGB())
 378             {
 379                 for (int x = clipped.getWidth(); --x >= 0;)
 380                 {
 381                     ((PixelRGB*) line)->set (col);
 382                     line += destData.pixelStride;
 383                 }
 384             }
 385             else
 386             {
 387                 for (int x = clipped.getWidth(); --x >= 0;)
 388                 {
 389                     *line = col.getAlpha();
 390                     line += destData.pixelStride;
 391                 }
 392             }
 393         }
 394     }
 395 }
 396
 397 //==============================================================================
 398 const Colour Image::getPixelAt (const int x, const int y) const
 399 {
 400     if (isPositiveAndBelow (x, getWidth()) && isPositiveAndBelow (y, getHeight()))
 401     {
 402         const BitmapData srcData (*this, x, y, 1, 1);
 403         return srcData.getPixelColour (0, 0);
 404     }
 405
 406     return Colour();
 407 }
 408
 409 void Image::setPixelAt (const int x, const int y, const Colour& colour)
 410 {
 411     if (isPositiveAndBelow (x, getWidth()) && isPositiveAndBelow (y, getHeight()))
 412     {
 413         const BitmapData destData (*this, x, y, 1, 1, BitmapData::writeOnly);
 414         destData.setPixelColour (0, 0, colour);
 415     }
 416 }
 417
 418 void Image::multiplyAlphaAt (const int x, const int y, const float multiplier)
 419 {
 420     if (isPositiveAndBelow (x, getWidth()) && isPositiveAndBelow (y, getHeight())
 421          && hasAlphaChannel())
 422     {
 423         const BitmapData destData (*this, x, y, 1, 1, BitmapData::readWrite);
 424
 425         if (isARGB())
 426             ((PixelARGB*) destData.data)->multiplyAlpha (multiplier);
 427         else
 428             *(destData.data) = (uint8) (*(destData.data) * multiplier);
 429     }
 430 }
 431
 432 void Image::multiplyAllAlphas (const float amountToMultiplyBy)
 433 {
 434     if (hasAlphaChannel())
 435     {
 436         const BitmapData destData (*this, 0, 0, getWidth(), getHeight(), BitmapData::readWrite);
 437
 438         if (isARGB())
 439         {
 440             for (int y = 0; y < destData.height; ++y)
 441             {
 442                 uint8* p = destData.getLinePointer (y);
 443
 444                 for (int x = 0; x < destData.width; ++x)
 445                 {
 446                     ((PixelARGB*) p)->multiplyAlpha (amountToMultiplyBy);
 447                     p += destData.pixelStride;
 448                 }
 449             }
 450         }
 451         else
 452         {
 453             for (int y = 0; y < destData.height; ++y)
 454             {
 455                 uint8* p = destData.getLinePointer (y);
 456
 457                 for (int x = 0; x < destData.width; ++x)
 458                 {
 459                     *p = (uint8) (*p * amountToMultiplyBy);
 460                     p += destData.pixelStride;
 461                 }
 462             }
 463         }
 464     }
 465     else
 466     {
 467         jassertfalse; // can't do this without an alpha-channel!
 468     }
 469 }
 470
 471 void Image::desaturate()
 472 {
 473     if (isARGB() || isRGB())
 474     {
 475         const BitmapData destData (*this, 0, 0, getWidth(), getHeight(), BitmapData::readWrite);
 476
 477         if (isARGB())
 478         {
 479             for (int y = 0; y < destData.height; ++y)
 480             {
 481                 uint8* p = destData.getLinePointer (y);
 482
 483                 for (int x = 0; x < destData.width; ++x)
 484                 {
 485                     ((PixelARGB*) p)->desaturate();
 486                     p += destData.pixelStride;
 487                 }
 488             }
 489         }
 490         else
 491         {
 492             for (int y = 0; y < destData.height; ++y)
 493             {
 494                 uint8* p = destData.getLinePointer (y);
 495
 496                 for (int x = 0; x < destData.width; ++x)
 497                 {
 498                     ((PixelRGB*) p)->desaturate();
 499                     p += destData.pixelStride;
 500                 }
 501             }
 502         }
 503     }
 504 }
 505
 506 void Image::createSolidAreaMask (RectangleList& result, const float alphaThreshold) const
 507 {
 508     if (hasAlphaChannel())
 509     {
 510         const uint8 threshold = (uint8) jlimit (0, 255, roundToInt (alphaThreshold * 255.0f));
 511         SparseSet<int> pixelsOnRow;
 512
 513         const BitmapData srcData (*this, 0, 0, getWidth(), getHeight());
 514
 515         for (int y = 0; y < srcData.height; ++y)
 516         {
 517             pixelsOnRow.clear();
 518             const uint8* lineData = srcData.getLinePointer (y);
 519
 520             if (isARGB())
 521             {
 522                 for (int x = 0; x < srcData.width; ++x)
 523                 {
 524                     if (((const PixelARGB*) lineData)->getAlpha() >= threshold)
 525                         pixelsOnRow.addRange (Range<int> (x, x + 1));
 526
 527                     lineData += srcData.pixelStride;
 528                 }
 529             }
 530             else
 531             {
 532                 for (int x = 0; x < srcData.width; ++x)
 533                 {
 534                     if (*lineData >= threshold)
 535                         pixelsOnRow.addRange (Range<int> (x, x + 1));
 536
 537                     lineData += srcData.pixelStride;
 538                 }
 539             }
 540
 541             for (int i = 0; i < pixelsOnRow.getNumRanges(); ++i)
 542             {
 543                 const Range<int> range (pixelsOnRow.getRange (i));
 544                 result.add (Rectangle<int> (range.getStart(), y, range.getLength(), 1));
 545             }
 546
 547             result.consolidate();
 548         }
 549     }
 550     else
 551     {
 552         result.add (0, 0, getWidth(), getHeight());
 553     }
 554 }
 555
 556 void Image::moveImageSection (int dx, int dy,
 557                               int sx, int sy,
 558                               int w, int h)
 559 {
 560     if (dx < 0)
 561     {
 562         w += dx;
 563         sx -= dx;
 564         dx = 0;
 565     }
 566
 567     if (dy < 0)
 568     {
 569         h += dy;
 570         sy -= dy;
 571         dy = 0;
 572     }
 573
 574     if (sx < 0)
 575     {
 576         w += sx;
 577         dx -= sx;
 578         sx = 0;
 579     }
 580
 581     if (sy < 0)
 582     {
 583         h += sy;
 584         dy -= sy;
 585         sy = 0;
 586     }
 587
 588     const int minX = jmin (dx, sx);
 589     const int minY = jmin (dy, sy);
 590
 591     w = jmin (w, getWidth() - jmax (sx, dx));
 592     h = jmin (h, getHeight() - jmax (sy, dy));
 593
 594     if (w > 0 && h > 0)
 595     {
 596         const int maxX = jmax (dx, sx) + w;
 597         const int maxY = jmax (dy, sy) + h;
 598
 599         const BitmapData destData (*this, minX, minY, maxX - minX, maxY - minY, BitmapData::readWrite);
 600
 601         uint8* dst       = destData.getPixelPointer (dx - minX, dy - minY);
 602         const uint8* src = destData.getPixelPointer (sx - minX, sy - minY);
 603
 604         const int lineSize = destData.pixelStride * w;
 605
 606         if (dy > sy)
 607         {
 608             while (--h >= 0)
 609             {
 610                 const int offset = h * destData.lineStride;
 611                 memmove (dst + offset, src + offset, lineSize);
 612             }
 613         }
 614         else if (dst != src)
 615         {
 616             while (--h >= 0)
 617             {
 618                 memmove (dst, src, lineSize);
 619                 dst += destData.lineStride;
 620                 src += destData.lineStride;
 621             }
 622         }
 623     }
 624 }
 625
 626
 627 END_JUCE_NAMESPACE