diff --git a/build_linux64/libamscppimglib4.linux64.a b/build_linux64/libamscppimglib4.linux64.a index 7e5fd13..f89cdf7 100644 Binary files a/build_linux64/libamscppimglib4.linux64.a and b/build_linux64/libamscppimglib4.linux64.a differ diff --git a/build_linux64/objstore/amscppimglib4_amsimage.o b/build_linux64/objstore/amscppimglib4_amsimage.o index 9984e9d..fadafd3 100644 Binary files a/build_linux64/objstore/amscppimglib4_amsimage.o and b/build_linux64/objstore/amscppimglib4_amsimage.o differ diff --git a/include/amscppimglib4/amscppimglib4.hpp b/include/amscppimglib4/amscppimglib4.hpp index 4cd7638..2152c9b 100644 --- a/include/amscppimglib4/amscppimglib4.hpp +++ b/include/amscppimglib4/amscppimglib4.hpp @@ -34,6 +34,19 @@ namespace ams const uint8_t& operator[](const int ind) const; }; + //a floating point pixel, normalized so that RGBA is + // between 0 and 1 + struct amsfloatpixel + { + public: + float R,G,B,A; + + amspixel(); + amspixel(float _R ,float _G, float _B, float _A); + uint8_t& operator[](const int ind); + const uint8_t& operator[](const int ind) const; + }; + class amsimage { public: @@ -79,13 +92,15 @@ namespace ams //todo //applies image with alpha blending - int apply_image(int I0, int J0, amsimage *img); + int apply_image(int x0, int y0, const amsimage *img); //applied color to any pixels where the bitplane's value is >= thresh - int apply_bitplane_nz(int I0, int J0, amsbitplane* bp, amspixel color, uint8_t thresh); - + int apply_bitplane_mask(int x0, int y0, const amsbitplane* bp, amspixel color, uint8_t thresh); + + amsfloatpixel interpolate(float x, float y); + //rescales the image with linear interpolation - int rescale(int nnx, int nny); + amsimage rescale(int nnx, int nny); }; int read_image(const char *fname, amsimage* image); @@ -129,7 +144,7 @@ namespace ams void setall(uint8_t val); //rescales the image with linear interpolation - int rescale(int _Nx, int _Ny); //todo + amsbitplane rescale(int _Nx, int _Ny); //todo }; diff --git a/src/amscppimglib4/amscppimglib4_amsimage.cpp b/src/amscppimglib4/amscppimglib4_amsimage.cpp index c20c290..1b7bac8 100644 --- a/src/amscppimglib4/amscppimglib4_amsimage.cpp +++ b/src/amscppimglib4/amscppimglib4_amsimage.cpp @@ -632,4 +632,191 @@ namespace ams return ret; } + void amsimage_apply_image_tf( + int threadnum, + int nthreads, + amsimage *imgto, + const amsimage *imgfrom, + int x0, int y0 + ) + { + int dx,dy; + int64_t N; + int64_t I,I0,I1,Is,Ix,Iy,Ia,Ib; + double r1,g1,b1,a1; + double r2,g2,b2,a2; + double r3,g3,b3,a3; + int r3i,g3i,b3i,a3i; + + dx = (imgfrom->Nx < (imgto->Nx-x0)) ? imgfrom->Nx : imgto->Nx-x0; + dx = (dx<0) ? 0 : dx; + dy = (imgfrom->Ny < (imgto->Ny-y0)) ? imgfrom->Ny : imgto->Ny-y0; + dy = (dy<0) ? 0 : dy; + N = dx*dy; + + Is = N/nthreads; + I0 = threadnum*Is; + I1 = (threadnumNy; + Ib = Ix + Iy*imgfrom->Ny; + + r1 = imgto->data[0 + 4*Ia]/255.0; + g1 = imgto->data[1 + 4*Ia]/255.0; + b1 = imgto->data[2 + 4*Ia]/255.0; + a1 = imgto->data[3 + 4*Ia]/255.0; + + r2 = imgfrom->data[0 + 4*Ib]/255.0; + g2 = imgfrom->data[1 + 4*Ib]/255.0; + b2 = imgfrom->data[2 + 4*Ib]/255.0; + a2 = imgfrom->data[3 + 4*Ib]/255.0; + + r3 = r1 + r2*(1.0-a2); + g3 = g1 + g2*(1.0-a2); + b3 = b1 + b2*(1.0-a2); + a3 = 1.0-(1.0-a1)*(1.0-a2); + + r3i = (int)(r3*255.0); + g3i = (int)(g3*255.0); + b3i = (int)(b3*255.0); + a3i = (int)(a3*255.0); + + r3i = (r3i>255) ? 255 : r3i; + g3i = (g3i>255) ? 255 : g3i; + b3i = (b3i>255) ? 255 : b3i; + a3i = (a3i>255) ? 255 : a3i; + + + imgto->data[0 + 4*Ia] = r3i; + imgto->data[1 + 4*Ia] = g3i; + imgto->data[2 + 4*Ia] = b3i; + imgto->data[3 + 4*Ia] = a3i; + } + + return; + } + + int amsimage::apply_image(int x0, int y0, const amsimage *img) + { + int ret = amsimage_success; + + int dx,dy; + int64_t N; + + if(img==NULL) + { + ret = amsimage_failure; + return ret; + } + + dx = (img->Nx < (this->Nx-x0)) ? img->Nx : this->Nx-x0; + dx = (dx<0) ? 0 : dx; + dy = (img->Ny < (this->Ny-y0)) ? img->Ny : this->Ny-y0; + dy = (dy<0) ? 0 : dy; + N = dx*dy; + + imglib4::threaded_execute( + amsimage_apply_image_tf, N, + this,img,x0,y0 + ); + + return ret; + } + + void amsimage_apply_bitplanemask_tf( + int threadnum, + int nthreads, + amsimage *imgto, + const amsbitplane *bpfrom, + amspixel color, + int x0, int y0, + uint8_t thresh + ) + { + int dx,dy; + int64_t N; + int64_t I,I0,I1,Is,Ix,Iy,Ia,Ib; + + + dx = (bpfrom->Nx < (imgto->Nx-x0)) ? bpfrom->Nx : imgto->Nx-x0; + dx = (dx<0) ? 0 : dx; + dy = (bpfrom->Ny < (imgto->Ny-y0)) ? bpfrom->Ny : imgto->Ny-y0; + dy = (dy<0) ? 0 : dy; + N = dx*dy; + + Is = N/nthreads; + I0 = threadnum*Is; + I1 = (threadnumNx*(Iy+y0); + Ib = Ix + bpfrom->Nx*Iy; + + if(bpfrom->data[Ib]>=thresh) + { + imgto->data[0 + 4*Ia] = color.R; + imgto->data[1 + 4*Ia] = color.G; + imgto->data[2 + 4*Ia] = color.B; + imgto->data[3 + 4*Ia] = color.A; + } + } + } + + //applied color to any pixels where the bitplane's value is >= thresh + int amsimage::apply_bitplane_mask(int x0, int y0, const amsbitplane* bp, amspixel color, uint8_t thresh) + { + int ret = amsimage_success; + + int dx,dy; + int64_t N; + + if(bp==NULL) + { + ret = amsimage_failure; + return ret; + } + + dx = (bp->Nx < (this->Nx-x0)) ? bp->Nx : this->Nx-x0; + dx = (dx<0) ? 0 : dx; + dy = (bp->Ny < (this->Ny-y0)) ? bp->Ny : this->Ny-y0; + dy = (dy<0) ? 0 : dy; + N = dx*dy; + + imglib4::threaded_execute( + amsimage_apply_bitplanemask_tf, N, + this,bp,color,x0,y0,thresh + ); + + return ret; + } + + amsfloatpixel amsimage::interpolate(float x, float y) + { + + } + + void amsimage_rescale_tf( + int threadnum, + int nthreads, + amsimage *imgto, + const amsimage *imgfrom + ) + { + + } + + amsimage amsimage::rescale(int nnx, int nny) + { + + } + }; \ No newline at end of file