static void report_before(MagickWand *mw, size_t size_in)
{
const double ks = size_in / 1024.;
fprintf(stdout,
"Before quality:%lu colors:%lu size:%5.1fkB type:%s format:%s ",
quality(mw),
(unsigned long)unique_colors(mw),
ks, type2str(MagickGetImageType(mw)),
MagickGetImageFormat(mw));
}
static PyObject *
im_GetImageType(PyObject *self, PyObject *args) {
void *magick_pointer;
MagickWand *magick_wand;
ImageType img_type;
if (!PyArg_ParseTuple(args, "O", &magick_pointer)){
Py_INCREF(Py_None);
return Py_None;
}
magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer);
img_type = MagickGetImageType(magick_wand);
if (img_type == BilevelType){
return Py_BuildValue("s", "BilevelType");
}
else if (img_type == GrayscaleType){
return Py_BuildValue("s", "GrayscaleType");
}
else if (img_type == GrayscaleMatteType){
return Py_BuildValue("s", "GrayscaleMatteType");
}
else if (img_type == PaletteType){
return Py_BuildValue("s", "PaletteType");
}
else if (img_type == PaletteMatteType){
return Py_BuildValue("s", "PaletteMatteType");
}
else if (img_type == TrueColorType){
return Py_BuildValue("s", "TrueColorType");
}
else if (img_type == TrueColorMatteType){
return Py_BuildValue("s", "TrueColorMatteType");
}
else if (img_type == ColorSeparationType){
return Py_BuildValue("s", "ColorSeparationType");
}
else if (img_type == ColorSeparationMatteType){
return Py_BuildValue("s", "ColorSeparationMatteType");
}
else if (img_type == OptimizeType){
return Py_BuildValue("s", "OptimizeType");
}
else if (img_type == PaletteBilevelMatteType){
return Py_BuildValue("s", "PaletteBilevelMatteType");
}
else {
return Py_BuildValue("s", "UndefinedType");
}
}
int64 c_Gmagick::t_getimagetype() {
INSTANCE_METHOD_INJECTION_BUILTIN(Gmagick, Gmagick::getimagetype);
checkNotEmpty();
return MagickGetImageType(magick_wand);
}
// Open Image
ptImage* ptImage::ptGMCOpenImage(const char* FileName,
short ColorSpace,
short Intent,
short ScaleFactor,
bool IsRAW,
TImage8RawData* ImgData,
bool& Success)
{
Success = 0;
MagickWand* image = NewMagickWand();
ExceptionType MagickExcept;
if (IsRAW) {
MagickReadImageBlob(image, (const uchar*)ImgData->data(), (const size_t)ImgData->size());
} else {
if (!QFile::exists(QString::fromLocal8Bit(FileName))) return this;
MagickReadImage(image, FileName);
}
MagickGetException(image, &MagickExcept);
if (MagickExcept != UndefinedException) {
return this;
}
Success = 1;
// Get the embedded profile
cmsHPROFILE InProfile = NULL;
if (MagickGetImageType(image) != GrayscaleType) {
ulong ProfileLength = 0;
uchar* IccProfile = MagickGetImageProfile(image, "ICC", &ProfileLength);
if (ProfileLength > 0) {
InProfile = cmsOpenProfileFromMem(IccProfile, ProfileLength);
}
}
if (!InProfile) {
InProfile = cmsCreate_sRGBProfile();
}
MagickSetImageType(image, TrueColorType);
MagickSetImageFormat(image, "RGB");
MagickSetImageDepth(image, 16);
uint16_t NewWidth = MagickGetImageWidth(image);
uint16_t NewHeight = MagickGetImageHeight(image);
// Buffer for the data from Magick
std::vector<std::array<float, 3> > ImageBuffer;
ImageBuffer.resize((size_t) NewWidth*NewHeight);
MagickGetImagePixels(image, 0, 0, NewWidth, NewHeight, "RGB", FloatPixel, (uchar*)ImageBuffer.data());
m_Width = NewWidth;
DestroyMagickWand(image);
// Image before color transform, may be binned
std::vector<std::array<float, 3> > NewImage;
if (ScaleFactor != 0) {
// Binning
NewHeight >>= ScaleFactor;
NewWidth >>= ScaleFactor;
short Step = 1 << ScaleFactor;
int Average = pow(2,2 * ScaleFactor);
NewImage.resize((size_t)NewWidth*NewHeight);
#pragma omp parallel for schedule(static)
for (uint16_t Row=0; Row < NewHeight*Step; Row+=Step) {
for (uint16_t Col=0; Col < NewWidth*Step; Col+=Step) {
float PixelValue[3] = {0.0f,0.0f,0.0f};
for (uint8_t sRow=0; sRow < Step; sRow++) {
for (uint8_t sCol=0; sCol < Step; sCol++) {
int32_t index = (Row+sRow)*m_Width+Col+sCol;
for (short c=0; c < 3; c++) {
PixelValue[c] += ImageBuffer[index][c];
}
}
}
for (short c=0; c < 3; c++) {
NewImage[Row/Step*NewWidth+Col/Step][c]
= PixelValue[c] / Average;
}
}
}
} else {
static void doit(const char *src, const char *dst, size_t oldsize,
const struct imgmin_options *opt)
{
MagickWand *mw, *tmp;
MagickBooleanType status;
double ks;
size_t newsize = oldsize + 1;
MagickWandGenesis();
mw = NewMagickWand();
/* load image... */
if (0 == strcmp("-", src))
{
/* ...from stdin */
# define BIGBUF (16 * 1024 * 1024)
char *blob = malloc(BIGBUF);
oldsize = read(STDIN_FILENO, blob, BIGBUF);
if (BIGBUF == oldsize)
{
fprintf(stderr, "Image too large for hardcoded imgmin stdin buffer\n");
exit(1);
}
MagickReadImageBlob(mw, blob, oldsize);
free(blob);
} else {
/* ...from disk */
status = MagickReadImage(mw, src);
if (status == MagickFalse)
ThrowWandException(mw);
}
ks = oldsize / 1024.;
fprintf(stderr,
"Before quality:%lu colors:%lu size:%5.1fkB type:%s ",
quality(mw),
(unsigned long)unique_colors(mw),
ks, type2str(MagickGetImageType(mw)));
tmp = search_quality(mw, dst, opt);
/* output image... */
{
unsigned char *blob = MagickGetImageBlob(tmp, &newsize);
/* if resulting image is larger than original, use original instead */
if (newsize > oldsize)
{
(void) MagickRelinquishMemory(blob);
blob = MagickGetImageBlob(mw, &newsize);
}
{
int fd;
if (0 == strcmp("-", dst))
{
fd = STDOUT_FILENO;
} else {
fd = open(dst, O_WRONLY | O_CREAT, 0644);
if (-1 == fd)
{
perror("open");
exit(1);
}
}
if ((ssize_t)newsize != write(fd, blob, newsize))
{
perror("write");
exit(1);
}
(void) MagickRelinquishMemory(blob);
if (fd != STDOUT_FILENO)
close(fd);
}
}
{
double kd = newsize / 1024.;
double ksave = ks - kd;
double kpct = ksave * 100. / ks;
fprintf(stderr,
"After quality:%lu colors:%lu size:%5.1fkB saved:%5.1fkB (%.1f%%)\n",
(unsigned long)quality(tmp),
(unsigned long)unique_colors(tmp),
kd, ksave, kpct);
}
/* tear it down */
DestroyMagickWand(tmp);
DestroyMagickWand(mw);
MagickWandTerminus();
}
