bool ofPixels_<PixelType>::pasteInto(ofPixels_<PixelType> &dst, int xTo, int yTo) const{
if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel() || xTo + getWidth()>dst.getWidth() || yTo + getHeight()>dst.getHeight()) return false;
int bytesToCopyPerRow = (xTo + getWidth()<=dst.getWidth() ? getWidth() : dst.getWidth()-xTo) * getBytesPerPixel();
int columnsToCopy = yTo + getHeight() <= dst.getHeight() ? getHeight() : dst.getHeight()-yTo;
PixelType * dstPix = dst.getData() + ((xTo + yTo*dst.getWidth())*dst.getBytesPerPixel());
const PixelType * srcPix = getData();
int srcStride = getWidth()*getBytesPerPixel();
int dstStride = dst.getWidth()*dst.getBytesPerPixel();
for(int y=0;y<columnsToCopy; y++){
memcpy(dstPix,srcPix,bytesToCopyPerRow);
dstPix += dstStride;
srcPix += srcStride;
}
return true;
}
bool ofPixels_<PixelType>::blendInto(ofPixels_<PixelType> &dst, int xTo, int yTo) const{
if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel() || xTo + getWidth()>dst.getWidth() || yTo + getHeight()>dst.getHeight() || getNumChannels()==0) return false;
std::function<void(const ConstPixel&,Pixel&)> blendFunc;
switch(getNumChannels()){
case 1:
blendFunc = [](const ConstPixel&src, Pixel&dst){
dst[0] = clampedAdd(src[0], dst[0]);
};
break;
case 2:
blendFunc = [](const ConstPixel&src, Pixel&dst){
dst[0] = clampedAdd(src[0], dst[0] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[1]));
dst[1] = clampedAdd(src[1], dst[1] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[1]));
};
break;
case 3:
blendFunc = [](const ConstPixel&src, Pixel&dst){
dst[0] = clampedAdd(src[0], dst[0]);
dst[1] = clampedAdd(src[1], dst[1]);
dst[2] = clampedAdd(src[2], dst[2]);
};
break;
case 4:
blendFunc = [](const ConstPixel&src, Pixel&dst){
dst[0] = clampedAdd(src[0], dst[0] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3]));
dst[1] = clampedAdd(src[1], dst[1] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3]));
dst[2] = clampedAdd(src[2], dst[2] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3]));
dst[3] = clampedAdd(src[3], dst[3] / ofColor_<PixelType>::limit() * (ofColor_<PixelType>::limit() - src[3]));
};
break;
}
auto dstLine = dst.getLine(yTo);
for(auto line: getConstLines()){
auto dstPixel = dstLine.getPixels().begin() + xTo;
for(auto p: line.getPixels()){
blendFunc(p,dstPixel);
dstPixel++;
}
dstLine++;
}
return true;
}
bool ofPixels_<PixelType>::resizeTo(ofPixels_<PixelType>& dst, ofInterpolationMethod interpMethod) const{
if(&dst == this){
return true;
}
if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel()) return false;
int srcWidth = getWidth();
int srcHeight = getHeight();
int dstWidth = dst.getWidth();
int dstHeight = dst.getHeight();
int bytesPerPixel = getBytesPerPixel();
PixelType * dstPixels = dst.getData();
switch (interpMethod){
//----------------------------------------
case OF_INTERPOLATE_NEAREST_NEIGHBOR:{
int dstIndex = 0;
float srcxFactor = (float)srcWidth/dstWidth;
float srcyFactor = (float)srcHeight/dstHeight;
float srcy = 0.5;
for (int dsty=0; dsty<dstHeight; dsty++){
float srcx = 0.5;
int srcIndex = int(srcy)*srcWidth;
for (int dstx=0; dstx<dstWidth; dstx++){
int pixelIndex = int(srcIndex + srcx) * bytesPerPixel;
for (int k=0; k<bytesPerPixel; k++){
dstPixels[dstIndex] = pixels[pixelIndex];
dstIndex++;
pixelIndex++;
}
srcx+=srcxFactor;
}
srcy+=srcyFactor;
}
}break;
//----------------------------------------
case OF_INTERPOLATE_BILINEAR:
// not implemented yet
ofLogError("ofPixels") << "resizeTo(): bilinear resize not implemented, not resizing";
break;
//----------------------------------------
case OF_INTERPOLATE_BICUBIC:
float px1, py1;
float px2, py2;
float px3, py3;
float srcColor = 0;
float interpCol;
int patchRow;
int patchIndex;
float patch[16];
int srcRowBytes = srcWidth*bytesPerPixel;
int loIndex = (srcRowBytes)+1;
int hiIndex = (srcWidth*srcHeight*bytesPerPixel)-(srcRowBytes)-1;
for (int dsty=0; dsty<dstHeight; dsty++){
for (int dstx=0; dstx<dstWidth; dstx++){
int dstIndex0 = (dsty*dstWidth + dstx) * bytesPerPixel;
float srcxf = srcWidth * (float)dstx/(float)dstWidth;
float srcyf = srcHeight * (float)dsty/(float)dstHeight;
int srcx = (int) MIN(srcWidth-1, srcxf);
int srcy = (int) MIN(srcHeight-1, srcyf);
int srcIndex0 = (srcy*srcWidth + srcx) * bytesPerPixel;
px1 = srcxf - srcx;
py1 = srcyf - srcy;
px2 = px1 * px1;
px3 = px2 * px1;
py2 = py1 * py1;
py3 = py2 * py1;
for (int k=0; k<bytesPerPixel; k++){
int dstIndex = dstIndex0+k;
int srcIndex = srcIndex0+k;
for (int dy=0; dy<4; dy++) {
patchRow = srcIndex + ((dy-1)*srcRowBytes);
for (int dx=0; dx<4; dx++) {
patchIndex = patchRow + (dx-1)*bytesPerPixel;
if ((patchIndex >= loIndex) && (patchIndex < hiIndex)) {
srcColor = pixels[patchIndex];
}
patch[dx*4 + dy] = srcColor;
}
}
interpCol = (PixelType)bicubicInterpolate(patch, px1,py1, px2,py2, px3,py3);
dstPixels[dstIndex] = interpCol;
}
}
}
break;
}
return true;
}
void ofPixels_<PixelType>::copyFrom(const ofPixels_<PixelType> & mom){
if(mom.isAllocated()) {
allocate(mom.getWidth(), mom.getHeight(), mom.getNumChannels());
memcpy(pixels, mom.getPixels(), mom.getWidth() * mom.getHeight() * mom.getBytesPerPixel());
}
}
