PDL-IO-Image

 view release on metacpan or  search on metacpan

Image.pd  view on Meta::CPAN

      if (RETVAL == NULL) croak("FAIL: Newz failed");
      FIBITMAP *newdib = FreeImage_Clone(self->dib);
      if (newdib == NULL) croak("FAIL: FreeImage_Clone failed");
      RETVAL->dib = newdib;
    }
    OUTPUT:
        RETVAL

void
dump_bitmap(PDL::IO::Image self, int target_bpp=0)
    PPCODE:
    {
      SV *bmp_sv, *pal_sv;
      unsigned char *bmp = NULL, *pal = NULL;
      unsigned w, h, bpp, cu, it, sz, szp, szl, y, i;
      FIBITMAP *newdib = NULL, *b = NULL;

      /* FIRST: we need FIT_BITMAP */
      it  = FreeImage_GetImageType(self->dib);
      if (it==FIT_RGB16 || it==FIT_RGBA16 || it==FIT_RGBF || it==FIT_RGBAF) {
        newdib = FreeImage_ToneMapping(self->dib, FITMO_REINHARD05, 0, 0);

Image.pd  view on Meta::CPAN

const char*
free_image_version(SV *class)
    CODE:
        RETVAL = FreeImage_GetVersion();
    OUTPUT:
        RETVAL

void
format_list(SV *class)
    PPCODE:
    {
        int i;
        for(i = 0; i < FreeImage_GetFIFCount(); i++) {
          if(FreeImage_IsPluginEnabled((FREE_IMAGE_FORMAT)i)) {
            const char *f = FreeImage_GetFormatFromFIF((FREE_IMAGE_FORMAT)i);
            XPUSHs(sv_2mortal(newSVpvn(f, strlen(f))));
          }
        }
    }

Image.pd  view on Meta::CPAN

unsigned
get_dots_per_meter_x(PDL::IO::Image self)
    CODE:
        RETVAL = FreeImage_GetDotsPerMeterX(self->dib);
    OUTPUT:
        RETVAL

void
set_dots_per_meter_x(PDL::IO::Image self, unsigned res)
    PPCODE:
        FreeImage_SetDotsPerMeterX(self->dib, res);
        XPUSHs(ST(0)); /* return self */

unsigned
get_dots_per_meter_y(PDL::IO::Image self)
    CODE:
        RETVAL = FreeImage_GetDotsPerMeterY(self->dib);
    OUTPUT:
        RETVAL

void
set_dots_per_meter_y(PDL::IO::Image self, unsigned res)
    PPCODE:
        FreeImage_SetDotsPerMeterY(self->dib, res);
        XPUSHs(ST(0)); /* return self */

const char*
get_color_type(PDL::IO::Image self)
    CODE:
        RETVAL = _fic2str(FreeImage_GetColorType(self->dib));
    OUTPUT:
        RETVAL

Image.pd  view on Meta::CPAN

int
get_transparent_index(PDL::IO::Image self)
    CODE:
        RETVAL = FreeImage_GetTransparentIndex(self->dib);
    OUTPUT:
        RETVAL

void
set_transparent_index(PDL::IO::Image self, int index)
    PPCODE:
        FreeImage_SetTransparentIndex(self->dib, index);
        XPUSHs(ST(0)); /* return self */

void
flip_horizontal(PDL::IO::Image self)
    PPCODE:
        if(!FreeImage_FlipHorizontal(self->dib)) {
          warn("FreeImage_FlipHorizontal failed");
        }
        XPUSHs(ST(0)); /* return self */

void
flip_vertical(PDL::IO::Image self)
    PPCODE:
        if(!FreeImage_FlipVertical(self->dib)) {
          warn("FreeImage_FlipVertical failed");
        }
        XPUSHs(ST(0)); /* return self */

void
convert_image_type(PDL::IO::Image self, SV * dst_image_type, int scale_linear=1)
    PPCODE:
    {
        FREE_IMAGE_TYPE fit = _sv2fit(dst_image_type);
        if (fit == FIT_UNKNOWN) {
          warn("invalid dst_image_type");
        }
        else {
          FIBITMAP *newdib = FreeImage_ConvertToType(self->dib, fit, scale_linear);
          if (newdib) {
            if (self->dib) FreeImage_Unload(self->dib);
            self->dib = newdib;
          }
          else {
            warn("FreeImage_ConvertToType (fit=%d) failed", fit);
          }
        }
        XPUSHs(ST(0)); /* return self */
    }

void
adjust_colors(PDL::IO::Image self, double brightness=0, double contrast=0, double gamma=0, int invert=0)
    PPCODE:
        if(!FreeImage_AdjustColors(self->dib, brightness, contrast, gamma, invert)) {
          warn("FreeImage_AdjustColors failed");
        }
        XPUSHs(ST(0)); /* return self */

void
tone_mapping(PDL::IO::Image self, int tmo, double p1=0, double p2=0)
    PPCODE:
        if (tmo == FITMO_DRAGO03 || tmo == FITMO_REINHARD05 || tmo == FITMO_FATTAL02) {
          FIBITMAP *newdib = FreeImage_ToneMapping(self->dib, tmo, p1, p2);
          if (newdib) {
            if (self->dib) FreeImage_Unload(self->dib);
            self->dib = newdib;
          }
          else {
            warn("FreeImage_ToneMapping (tmp=%d) failed", tmo);
          }
        }
        else {
          warn("invalid tone mapping operator");
        }
        XPUSHs(ST(0)); /* return self */

void
rotate(PDL::IO::Image self, double angle, ...)
    PPCODE:
    {
        FIBITMAP *newdib = NULL;
        unsigned bpp = FreeImage_GetBPP(self->dib);
        FREE_IMAGE_TYPE fit = FreeImage_GetImageType(self->dib);

        if (items > 2) {
          switch(fit) {
            case FIT_BITMAP:
              switch(bpp) {
                case 8:

Image.pd  view on Meta::CPAN

          self->dib = newdib;
        }
        else {
          warn("FreeImage_Rotate failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_dither(PDL::IO::Image self, int algorithm=FID_FS)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_Dither(self->dib, algorithm);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_Dither failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_threshhold(PDL::IO::Image self, unsigned threshold=127)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_Threshold(self->dib, (BYTE)threshold);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_Threshold failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_quantize(PDL::IO::Image self, int quantize=FIQ_WUQUANT)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ColorQuantize(self->dib, quantize);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ColorQuantize failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_4bpp(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertTo4Bits(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertTo4Bits failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_8bpp(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertTo8Bits(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertTo8Bits failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_8bpp_grey(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertToGreyscale(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertToGreyscale failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_16bpp_555(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertTo16Bits555(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertTo16Bits555 failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_16bpp_565(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertTo16Bits565(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertTo16Bits565 failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_24bpp(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertTo24Bits(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertTo24Bits failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
color_to_32bpp(PDL::IO::Image self)
    PPCODE:
    {
        FIBITMAP *newdib = FreeImage_ConvertTo32Bits(self->dib);
        if (newdib) {
          if (self->dib) FreeImage_Unload(self->dib);
          self->dib = newdib;
        }
        else {
          warn("FreeImage_ConvertTo32Bits failed");
        }
        XPUSHs(ST(0)); /* return self */
    }

void
rescale(PDL::IO::Image self, int dst_width=0, int dst_height=0, int filter=FILTER_CATMULLROM)
    PPCODE:
    {
        if (dst_height<=0 && dst_width>0) {
          double ratio = (double)dst_width / (double)FreeImage_GetWidth(self->dib);
          dst_height   = (int)floor(0.5 + ratio * (double)FreeImage_GetHeight(self->dib));
        }
        else if (dst_width<=0 && dst_height>0) {
          double ratio = (double)dst_height / (double)FreeImage_GetHeight(self->dib);
          dst_width    = (int)floor(0.5 + ratio * (double)FreeImage_GetWidth(self->dib));
        }
        if (dst_height>0 && dst_width>0) {

Image.pd  view on Meta::CPAN

          }
          else {
            warn("FreeImage_Rescale failed");
          }
        }
        XPUSHs(ST(0)); /* return self */
    }

void
rescale_pct(PDL::IO::Image self, double dst_width_pct=0, double dst_height_pct=0, int filter=FILTER_CATMULLROM)
    PPCODE:
    {
        int dst_height = (int)floor(0.5 + (double)FreeImage_GetHeight(self->dib) * dst_height_pct / 100.0);
        int dst_width  = (int)floor(0.5 + (double)FreeImage_GetWidth(self->dib)  * dst_width_pct  / 100.0);

        if (dst_height<=0 && dst_width>0) {
          double ratio = (double)dst_width / (double)FreeImage_GetWidth(self->dib);
          dst_height   = (int)floor(0.5 + ratio * (double)FreeImage_GetHeight(self->dib));
        }
        else if (dst_width<=0 && dst_height>0) {
          double ratio = (double)dst_height / (double)FreeImage_GetHeight(self->dib);

Image.pd  view on Meta::CPAN

          }
          else {
            warn("FreeImage_Rescale failed");
          }
        }
        XPUSHs(ST(0)); /* return self */
    }

void
save(PDL::IO::Image self, SV * destination, SV * f=NULL, int flags=0);
    PPCODE:
    {
        if (self->dib) {
          FIMEMORY *hmem = NULL;
          BYTE *mem_buffer = NULL;
          DWORD size_in_bytes = 0;
          FREE_IMAGE_FORMAT fif = _sv2fif(f);
          FREE_IMAGE_TYPE fit = FreeImage_GetImageType(self->dib);

          if(SvROK(destination) && SvTYPE(SvRV(destination)) < SVt_PVAV) {
            /* destination is a reference to scalar */

const-xs.inc  view on Meta::CPAN

	dTARGET;
#endif
	STRLEN		len;
        int		type;
	IV		iv;
	/* NV		nv;	Uncomment this if you need to return NVs */
	/* const char	*pv;	Uncomment this if you need to return PVs */
    INPUT:
	SV *		sv;
        const char *	s = SvPV(sv, len);
    PPCODE:
        /* Change this to constant(aTHX_ s, len, &iv, &nv);
           if you need to return both NVs and IVs */
	type = constant(aTHX_ s, len, &iv);
      /* Return 1 or 2 items. First is error message, or undef if no error.
           Second, if present, is found value */
        switch (type) {
        case PERL_constant_NOTFOUND:
          sv =
	    sv_2mortal(newSVpvf("%s is not a valid PDL::IO::Image macro", s));
          PUSHs(sv);