void CImageView::ZoomOut(void)
{
if (m_szAjustedBitmapSize.cx > 3 && m_szAjustedBitmapSize.cy > 3)
{
int nHorPos = GetScrollPos(m_hwnd, SB_HORZ);
int nVertPos = GetScrollPos(m_hwnd, SB_VERT);
float fltRatio = (float)m_szAjustedBitmapSize.cx / (float)m_szBitmapSize.cx * 2.0f / 3.0f;
SIZE szOldAjustedBitmapSize = m_szAjustedBitmapSize;
m_szAjustedBitmapSize.cx = (int)((float)m_szBitmapSize.cx * fltRatio);
m_szAjustedBitmapSize.cy = (int)((float)m_szBitmapSize.cy * fltRatio);
ResizeImage();
if (m_hAdjustedBitmap != NULL)
{
ResizeImageView(FALSE);
SetScrollPos(m_hwnd, SB_HORZ, nHorPos * 2 / 3, TRUE);
SetScrollPos(m_hwnd, SB_VERT, nVertPos * 2 / 3, TRUE);
InvalidateRect(m_hwnd, NULL, FALSE);
}
else
{
m_szAjustedBitmapSize = szOldAjustedBitmapSize;
ResizeImage();
}
}
}
int main() {
std::vector<cv::Mat> images = CreateTestMats();
cv::Mat uflow, cflow, flow;
cv::calcOpticalFlowFarneback(images[0], images[1], uflow, 0.5, 3, 5, 3, 5,
1.1, 0);
auto optical_flow = oflow::utils::GetOpticalFlow(uflow);
// cv::cvtColor(images[0], cflow, cv::COLOR_GRAY2BGR);
// uflow.copyTo(flow);
// cv::drawOptFlowMap(flow, cflow, 11, 1.5, cv::Scalar(0, 255, 0));
cv::namedWindow("Magnitude", 1);
imshow("Magnitude", ResizeImage(optical_flow.GetMagnitude()));
cv::namedWindow("Vx", 1);
imshow("Vx", ResizeImage(optical_flow.GetVx()));
cv::namedWindow("Vy", 1);
imshow("Vy", ResizeImage(optical_flow.GetVy()));
cv::namedWindow("Orientation", 1);
imshow("Orientation", ResizeImage(optical_flow.GetOrientation()));
std::cout << "Orientation: " << std::endl << optical_flow.GetOrientation()
<< std::endl;
cv::waitKey(0);
}
Image *AutoResizeImage(const Image *image,const char *option,
MagickOffsetType *count,ExceptionInfo *exception)
{
#define MAX_SIZES 16
char
*q;
const char
*p;
Image
*resized,
*images;
register ssize_t
i;
size_t
sizes[MAX_SIZES]={256,192,128,96,64,48,40,32,24,16};
images=NULL;
*count=0;
i=0;
p=option;
while (*p != '\0' && i < MAX_SIZES)
{
size_t
size;
while ((isspace((int) ((unsigned char) *p)) != 0))
p++;
size=(size_t)strtol(p,&q,10);
if ((p == q) || (size < 16) || (size > 256))
return((Image *) NULL);
p=q;
sizes[i++]=size;
while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
p++;
}
if (i==0)
i=10;
*count=i;
for (i=0; i < *count; i++)
{
resized=ResizeImage(image,sizes[i],sizes[i],image->filter,exception);
if (resized == (Image *) NULL)
return(DestroyImageList(images));
if (images == (Image *) NULL)
images=resized;
else
AppendImageToList(&images,resized);
}
return(images);
}
void CImageView::FitImage(void)
{
RECT rcClient;
GetBiggestClientRect(&rcClient);
if (rcClient.right < m_szBitmapSize.cx || rcClient.bottom < m_szBitmapSize.cy)
{
int nProduct1 = rcClient.right * m_szBitmapSize.cy;
int nProduct2 = rcClient.bottom * m_szBitmapSize.cx;
if (nProduct1 < nProduct2)
{
m_szAjustedBitmapSize.cx = rcClient.right;
m_szAjustedBitmapSize.cy = nProduct1 / m_szBitmapSize.cx;
}
else
{
m_szAjustedBitmapSize.cx = nProduct2 / m_szBitmapSize.cy;
m_szAjustedBitmapSize.cy = rcClient.bottom;
}
}
else
m_szAjustedBitmapSize = m_szBitmapSize;
ResizeImage();
ResizeImageView(TRUE);
InvalidateRect(m_hwnd, NULL, FALSE);
}
void CImageView::ResetSize(void)
{
m_szAjustedBitmapSize = m_szBitmapSize;
ResizeImage();
ResizeImageView(TRUE);
InvalidateRect(m_hwnd, NULL, FALSE);
}
// The function that does the real detection
int DetectionScanner::FastScan(IntImage<double>& original,std::vector<cv::Rect>& results,const int stepsize)
{
if(original.nrow<height+5 || original.ncol<width+5) return 0;
const int hd = height/xdiv;
const int wd = width/ydiv;
InitImage(original);
results.clear();
hist.Create(1,baseflength*(xdiv-EXT)*(ydiv-EXT));
NodeDetector* node = cascade->nodes[1];
double** pc = node->classifier.p;
int oheight = original.nrow, owidth = original.ncol;
cv::Rect rect;
while(image.nrow>=height && image.ncol>=width)
{
InitIntegralImages(stepsize);
for(int i=2; i+height<image.nrow-2; i+=stepsize)
{
const double* sp = scores.p[i];
for(int j=2; j+width<image.ncol-2; j+=stepsize)
{
if(sp[j]<=0) continue;
int* p = hist.buf;
hist.Zero();
for(int k=0; k<xdiv-EXT; k++)
{
for(int t=0; t<ydiv-EXT; t++)
{
for(int x=i+k*hd+1; x<i+(k+1+EXT)*hd-1; x++)
{
int* ctp = ct.p[x];
for(int y=j+t*wd+1; y<j+(t+1+EXT)*wd-1; y++)
p[ctp[y]]++;
}
p += baseflength;
}
}
double score = node->thresh;
for(int k=0; k<node->classifier.nrow; k++) score += pc[k][hist.buf[k]];
if(score>0)
{
rect.y = i * oheight / image.nrow;
rect.height = (oheight * height) / image.nrow + 1;
rect.x = j * owidth / image.ncol;
rect.width = (width * owidth) /image.ncol + 1;
results.push_back(rect);
}
}
}
ResizeImage();
}
return 0;
}
void ImageData::ResizeImage(
const double scale_factor,
const ResizeInterpolationMethod interpolation_method) {
// Undefined behavior if image is empty.
CHECK(!channels_.empty()) << "Cannot resize an empty image.";
CHECK_GT(scale_factor, 0) << "Scale factor must be larger than 0.";
cv::Size new_size(
static_cast<int>(image_size_.width * scale_factor),
static_cast<int>(image_size_.height * scale_factor));
ResizeImage(new_size, interpolation_method);
}
Image *resize_image(Image *img, int re_columns, int re_rows, FilterTypes filter, int blur){
Image *new_img = NULL;
ExceptionInfo exception;
GetExceptionInfo(&exception);
// Filter type : http://www.graphicsmagick.org/api/types.html#filtertypes
// Blur: The blur factor where > 1 is blurry, < 1 is sharp.
new_img = ResizeImage(img, re_columns, re_rows, filter, blur, &exception);
DestroyImage(img);
SyncImagePixels(new_img);
return (new_img);
}
void ImageMultiplexer::AddImage(const std::string& strComputer, ImageTopic topic, const cv::Mat& image)
{
unsigned int width;
unsigned int height;
GetImageDimensions(width, height);
cv::Mat resizedImage = ResizeImage(image, width, height);
cv::Point point1;
cv::Point point2;
if (GetDestination(strComputer, topic, point1, point2))
{
// TODO: Copy resizedImage to m_image from point1 to point2
}
}
void CIMDisplayView::OnResize()
{
CIMDisplayDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
CResizeDialog dlg;
dlg.Width( pDoc->GetImage().columns() );
dlg.Height( pDoc->GetImage().rows() );
if ( dlg.DoModal() == IDOK ) {
Geometry newGeo( dlg.Width(), dlg.Height() );
newGeo.percent( dlg.IsPercentage() );
ResizeImage( newGeo );
}
}
struct fp_img *fpi_im_resize(struct fp_img *img, unsigned int factor)
{
Image *mimg;
Image *resized;
ExceptionInfo exception;
MagickBooleanType ret;
int new_width = img->width * factor;
int new_height = img->height * factor;
struct fp_img *newimg;
/* It is possible to implement resizing using a simple algorithm, however
* we use ImageMagick because it applies some kind of smoothing to the
* result, which improves matching performances in my experiments. */
if (!IsMagickInstantiated())
InitializeMagick(NULL);
GetExceptionInfo(&exception);
mimg = ConstituteImage(img->width, img->height, "I", CharPixel, img->data,
&exception);
GetExceptionInfo(&exception);
resized = ResizeImage(mimg, new_width, new_height, 0, 1.0, &exception);
newimg = fpi_img_new(new_width * new_height);
newimg->width = new_width;
newimg->height = new_height;
newimg->flags = img->flags;
GetExceptionInfo(&exception);
ret = ExportImagePixels(resized, 0, 0, new_width, new_height, "I",
CharPixel, newimg->data, &exception);
if (ret != MagickTrue) {
fp_err("export failed");
return NULL;
}
DestroyImage(mimg);
DestroyImage(resized);
return newimg;
}
bool SURFFeatureManager::GetFeature(const std::string& image_path,
SURFFeature *feature) {
cv::Mat original_image = cv::imread(image_path, CV_LOAD_IMAGE_GRAYSCALE);
if (!original_image.data) return false;
ResizeImage(original_image, feature->image);
// Detect key points
cv::SurfFeatureDetector(kMinHessian).detect(feature->image,
feature->key_points);
// Extract descriptor
cv::SurfDescriptorExtractor().compute(feature->image,
feature->key_points,
feature->descriptor);
// Set ROI
cv::Size size = feature->image.size();
feature->roi.x = 0;
feature->roi.y = 0;
feature->roi.width = size.width;
feature->roi.height = size.height;
return true;
}
bool GuillotineImageAtlas::ResizeLayer(Layer& layer, const Vector2ui& size)
{
AbstractImage* oldLayer = layer.image.get();
std::unique_ptr<AbstractImage> newImage(ResizeImage(layer.image.get(), size));
if (!newImage)
return false; // Nous n'avons pas pu allouer
if (newImage.get() == oldLayer) // Le layer a été agrandi dans le même objet, pas de souci
{
newImage.release(); // On possède déjà un unique_ptr sur cette ressource
return true;
}
// On indique à ceux que ça intéresse qu'on a changé de pointeur
// (chose très importante pour ceux qui le stockent)
OnAtlasLayerChange(this, layer.image.get(), newImage.get());
// Et on ne met à jour le pointeur qu'après (car cette ligne libère également l'ancienne image)
layer.image = std::move(newImage);
return true;
}
int FResizeImage( struct ImageLibrary *im, Image **image, int w, int h )
{
if( image != NULL )
{
ExceptionInfo *ei=AcquireExceptionInfo();
///filters are in resamples.h
Image* newImage = ResizeImage( *image, w, h, LanczosFilter, 1.0, ei );
if( newImage != NULL )
{
DeleteImage( *image );
*image = newImage;
}
DestroyExceptionInfo( ei );
}
else
{
ERROR("Cannot resize empty image\n");
}
return 0;
}
/*
* Initialization function for an X Athena Widget module to Angband
*
* We should accept "-d<dpy>" requests in the "argv" array. XXX XXX XXX
*/
errr init_xaw(int argc, char *argv[])
{
int i;
Widget topLevel;
Display *dpy;
cptr dpy_name = "";
#ifdef USE_GRAPHICS
char filename[1024];
int pict_wid = 0;
int pict_hgt = 0;
#ifdef USE_TRANSPARENCY
char *TmpData;
#endif /* USE_TRANSPARENCY */
#endif /* USE_GRAPHICS */
/* Parse args */
for (i = 1; i < argc; i++)
{
if (prefix(argv[i], "-d"))
{
dpy_name = &argv[i][2];
continue;
}
#ifdef USE_GRAPHICS
if (prefix(argv[i], "-s"))
{
smoothRescaling = FALSE;
continue;
}
#endif /* USE_GRAPHICS */
if (prefix(argv[i], "-n"))
{
num_term = atoi(&argv[i][2]);
if (num_term > MAX_TERM_DATA) num_term = MAX_TERM_DATA;
else if (num_term < 1) num_term = 1;
continue;
}
plog_fmt("Ignoring option: %s", argv[i]);
}
/* Attempt to open the local display */
dpy = XOpenDisplay(dpy_name);
/* Failure -- assume no X11 available */
if (!dpy) return (-1);
/* Close the local display */
XCloseDisplay(dpy);
#ifdef USE_XAW_LANG
/* Support locale processing */
XtSetLanguageProc(NULL, NULL, NULL);
#endif /* USE_XAW_LANG */
/* Initialize the toolkit */
topLevel = XtAppInitialize(&appcon, "Angband", NULL, 0, &argc, argv,
fallback, NULL, 0);
/* Initialize the windows */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
term_data_init(td, topLevel, 1024, termNames[i],
(i == 0) ? specialArgs : defaultArgs,
TERM_FALLBACKS, i);
angband_term[i] = Term;
}
/* Activate the "Angband" window screen */
Term_activate(&data[0].t);
/* Raise the "Angband" window */
term_raise(&data[0]);
#ifdef USE_GRAPHICS
/* Try graphics */
if (arg_graphics)
{
/* Try the "16x16.bmp" file */
path_build(filename, 1024, ANGBAND_DIR_XTRA, "graf/16x16.bmp");
/* Use the "16x16.bmp" file if it exists */
if (0 == fd_close(fd_open(filename, O_RDONLY)))
{
/* Use graphics */
use_graphics = TRUE;
use_transparency = TRUE;
pict_wid = pict_hgt = 16;
ANGBAND_GRAF = "new";
}
else
{
/* Try the "8x8.bmp" file */
path_build(filename, 1024, ANGBAND_DIR_XTRA, "graf/8x8.bmp");
/* Use the "8x8.bmp" file if it exists */
if (0 == fd_close(fd_open(filename, O_RDONLY)))
{
/* Use graphics */
use_graphics = TRUE;
pict_wid = pict_hgt = 8;
ANGBAND_GRAF = "old";
}
}
}
/* Load graphics */
if (use_graphics)
{
/* Hack -- Get the Display */
term_data *td = &data[0];
Widget widget = (Widget)(td->widget);
Display *dpy = XtDisplay(widget);
XImage *tiles_raw;
/* Load the graphical tiles */
tiles_raw = ReadBMP(dpy, filename);
/* Initialize the windows */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
term *t = &td->t;
t->pict_hook = Term_pict_xaw;
t->higher_pict = TRUE;
/* Resize tiles */
td->widget->angband.tiles =
ResizeImage(dpy, tiles_raw,
pict_wid, pict_hgt,
td->widget->angband.fontwidth,
td->widget->angband.fontheight);
}
#ifdef USE_TRANSPARENCY
/* Initialize the transparency temp storage*/
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
int ii, jj;
int depth = DefaultDepth(dpy, DefaultScreen(dpy));
Visual *visual = DefaultVisual(dpy, DefaultScreen(dpy));
int total;
/* Determine total bytes needed for image */
ii = 1;
jj = (depth - 1) >> 2;
while (jj >>= 1) ii <<= 1;
total = td->widget->angband.fontwidth *
td->widget->angband.fontheight * ii;
TmpData = (char *)malloc(total);
td->widget->angband.TmpImage = XCreateImage(dpy,
visual,depth,
ZPixmap, 0, TmpData,
td->widget->angband.fontwidth,
td->widget->angband.fontheight, 8, 0);
}
#endif /* USE_TRANSPARENCY */
/* Free tiles_raw? XXX XXX */
}
#endif /* USE_GRAPHICS */
/* Success */
return (0);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e P I C O N I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WritePICONImage() writes an image to a file in the Personal Icon format.
%
% The format of the WritePICONImage method is:
%
% MagickBooleanType WritePICONImage(const ImageInfo *image_info,
% Image *image)
%
% A description of each parameter follows.
%
% o image_info: the image info.
%
% o image: The image.
%
*/
static MagickBooleanType WritePICONImage(const ImageInfo *image_info,
Image *image)
{
#define ColormapExtent 155
#define GraymapExtent 95
#define PiconGeometry "48x48>"
static unsigned char
Colormap[]=
{
0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x06, 0x00, 0x05, 0x00, 0xf4, 0x05,
0x00, 0x00, 0x00, 0x00, 0x2f, 0x4f, 0x4f, 0x70, 0x80, 0x90, 0x7e, 0x7e,
0x7e, 0xdc, 0xdc, 0xdc, 0xff, 0xff, 0xff, 0x00, 0x00, 0x80, 0x00, 0x00,
0xff, 0x1e, 0x90, 0xff, 0x87, 0xce, 0xeb, 0xe6, 0xe6, 0xfa, 0x00, 0xff,
0xff, 0x80, 0x00, 0x80, 0xb2, 0x22, 0x22, 0x2e, 0x8b, 0x57, 0x32, 0xcd,
0x32, 0x00, 0xff, 0x00, 0x98, 0xfb, 0x98, 0xff, 0x00, 0xff, 0xff, 0x00,
0x00, 0xff, 0x63, 0x47, 0xff, 0xa5, 0x00, 0xff, 0xd7, 0x00, 0xff, 0xff,
0x00, 0xee, 0x82, 0xee, 0xa0, 0x52, 0x2d, 0xcd, 0x85, 0x3f, 0xd2, 0xb4,
0x8c, 0xf5, 0xde, 0xb3, 0xff, 0xfa, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
0x00, 0x00, 0x06, 0x00, 0x05, 0x00, 0x00, 0x05, 0x18, 0x20, 0x10, 0x08,
0x03, 0x51, 0x18, 0x07, 0x92, 0x28, 0x0b, 0xd3, 0x38, 0x0f, 0x14, 0x49,
0x13, 0x55, 0x59, 0x17, 0x96, 0x69, 0x1b, 0xd7, 0x85, 0x00, 0x3b,
},
Graymap[]=
{
0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x04, 0x00, 0x04, 0x00, 0xf3, 0x0f,
0x00, 0x00, 0x00, 0x00, 0x12, 0x12, 0x12, 0x21, 0x21, 0x21, 0x33, 0x33,
0x33, 0x45, 0x45, 0x45, 0x54, 0x54, 0x54, 0x66, 0x66, 0x66, 0x78, 0x78,
0x78, 0x87, 0x87, 0x87, 0x99, 0x99, 0x99, 0xab, 0xab, 0xab, 0xba, 0xba,
0xba, 0xcc, 0xcc, 0xcc, 0xde, 0xde, 0xde, 0xed, 0xed, 0xed, 0xff, 0xff,
0xff, 0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04, 0x0c, 0x10, 0x04, 0x31,
0x48, 0x31, 0x07, 0x25, 0xb5, 0x58, 0x73, 0x4f, 0x04, 0x00, 0x3b,
};
#define MaxCixels 92
static const char
Cixel[MaxCixels+1] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjk"
"lzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
char
buffer[MaxTextExtent],
basename[MaxTextExtent],
name[MaxTextExtent],
symbol[MaxTextExtent];
ExceptionInfo
*exception;
Image
*affinity_image,
*picon;
ImageInfo
*blob_info;
MagickBooleanType
status,
transparent;
MagickPixelPacket
pixel;
QuantizeInfo
*quantize_info;
RectangleInfo
geometry;
register const IndexPacket
*indexes;
register const PixelPacket
*p;
register ssize_t
i,
x;
register PixelPacket
*q;
size_t
characters_per_pixel,
colors;
ssize_t
j,
k,
y;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
(void) TransformImageColorspace(image,sRGBColorspace);
SetGeometry(image,&geometry);
(void) ParseMetaGeometry(PiconGeometry,&geometry.x,&geometry.y,
&geometry.width,&geometry.height);
picon=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,1.0,
&image->exception);
blob_info=CloneImageInfo(image_info);
(void) AcquireUniqueFilename(blob_info->filename);
if ((image_info->type != TrueColorType) &&
(SetImageGray(image,&image->exception) != MagickFalse))
affinity_image=BlobToImage(blob_info,Graymap,GraymapExtent,
&image->exception);
else
affinity_image=BlobToImage(blob_info,Colormap,ColormapExtent,
&image->exception);
(void) RelinquishUniqueFileResource(blob_info->filename);
blob_info=DestroyImageInfo(blob_info);
if ((picon == (Image *) NULL) || (affinity_image == (Image *) NULL))
return(MagickFalse);
quantize_info=AcquireQuantizeInfo(image_info);
status=RemapImage(quantize_info,picon,affinity_image);
quantize_info=DestroyQuantizeInfo(quantize_info);
affinity_image=DestroyImage(affinity_image);
transparent=MagickFalse;
exception=(&image->exception);
if (picon->storage_class == PseudoClass)
{
(void) CompressImageColormap(picon);
if (picon->matte != MagickFalse)
transparent=MagickTrue;
}
else
{
/*
Convert DirectClass to PseudoClass picon.
*/
if (picon->matte != MagickFalse)
{
/*
Map all the transparent pixels.
*/
for (y=0; y < (ssize_t) picon->rows; y++)
{
q=GetAuthenticPixels(picon,0,y,picon->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) picon->columns; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
transparent=MagickTrue;
else
SetPixelOpacity(q,OpaqueOpacity);
q++;
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
}
}
(void) SetImageType(picon,PaletteType);
}
colors=picon->colors;
if (transparent != MagickFalse)
{
register IndexPacket
*indexes;
colors++;
picon->colormap=(PixelPacket *) ResizeQuantumMemory((void **)
picon->colormap,(size_t) colors,sizeof(*picon->colormap));
if (picon->colormap == (PixelPacket *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationError");
for (y=0; y < (ssize_t) picon->rows; y++)
{
q=GetAuthenticPixels(picon,0,y,picon->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(picon);
for (x=0; x < (ssize_t) picon->columns; x++)
{
if (q->opacity == (Quantum) TransparentOpacity)
SetPixelIndex(indexes+x,picon->colors);
q++;
}
if (SyncAuthenticPixels(picon,exception) == MagickFalse)
break;
}
}
/*
Compute the character per pixel.
*/
characters_per_pixel=1;
for (k=MaxCixels; (ssize_t) colors > k; k*=MaxCixels)
characters_per_pixel++;
/*
XPM header.
*/
(void) WriteBlobString(image,"/* XPM */\n");
GetPathComponent(picon->filename,BasePath,basename);
(void) FormatLocaleString(buffer,MaxTextExtent,
"static char *%s[] = {\n",basename);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"/* columns rows colors chars-per-pixel */\n");
(void) FormatLocaleString(buffer,MaxTextExtent,
"\"%.20g %.20g %.20g %.20g\",\n",(double) picon->columns,(double)
picon->rows,(double) colors,(double) characters_per_pixel);
(void) WriteBlobString(image,buffer);
GetMagickPixelPacket(image,&pixel);
for (i=0; i < (ssize_t) colors; i++)
{
/*
Define XPM color.
*/
SetMagickPixelPacket(image,picon->colormap+i,(IndexPacket *) NULL,&pixel);
pixel.colorspace=sRGBColorspace;
pixel.depth=8;
pixel.opacity=(MagickRealType) OpaqueOpacity;
(void) QueryMagickColorname(image,&pixel,XPMCompliance,name,
&image->exception);
if (transparent != MagickFalse)
{
if (i == (ssize_t) (colors-1))
(void) CopyMagickString(name,"grey75",MaxTextExtent);
}
/*
Write XPM color.
*/
k=i % MaxCixels;
symbol[0]=Cixel[k];
for (j=1; j < (ssize_t) characters_per_pixel; j++)
{
k=((i-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s c %s\",\n",
symbol,name);
(void) WriteBlobString(image,buffer);
}
/*
Define XPM pixels.
*/
(void) WriteBlobString(image,"/* pixels */\n");
for (y=0; y < (ssize_t) picon->rows; y++)
{
p=GetVirtualPixels(picon,0,y,picon->columns,1,&picon->exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetVirtualIndexQueue(picon);
(void) WriteBlobString(image,"\"");
for (x=0; x < (ssize_t) picon->columns; x++)
{
k=((ssize_t) GetPixelIndex(indexes+x) % MaxCixels);
symbol[0]=Cixel[k];
for (j=1; j < (ssize_t) characters_per_pixel; j++)
{
k=(((int) GetPixelIndex(indexes+x)-k)/MaxCixels) % MaxCixels;
symbol[j]=Cixel[k];
}
symbol[j]='\0';
(void) CopyMagickString(buffer,symbol,MaxTextExtent);
(void) WriteBlobString(image,buffer);
}
(void) FormatLocaleString(buffer,MaxTextExtent,"\"%s\n",
y == (ssize_t) (picon->rows-1) ? "" : ",");
(void) WriteBlobString(image,buffer);
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
picon->rows);
if (status == MagickFalse)
break;
}
picon=DestroyImage(picon);
(void) WriteBlobString(image,"};\n");
(void) CloseBlob(image);
return(MagickTrue);
}
void CIMDisplayView::OnOriginalsize()
{
ResizeImage( mBaseGeo );
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadImage() reads an image or image sequence from a file or file handle.
% The method returns a NULL if there is a memory shortage or if the image
% cannot be read. On failure, a NULL image is returned and exception
% describes the reason for the failure.
%
% The format of the ReadImage method is:
%
% Image *ReadImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: Read the image defined by the file or filename members of
% this structure.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *ReadImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
char
filename[MaxTextExtent],
magick[MaxTextExtent],
magick_filename[MaxTextExtent];
const char
*value;
const DelegateInfo
*delegate_info;
const MagickInfo
*magick_info;
ExceptionInfo
*sans_exception;
GeometryInfo
geometry_info;
Image
*image,
*next;
ImageInfo
*read_info;
MagickStatusType
flags,
thread_support;
PolicyDomain
domain;
PolicyRights
rights;
/*
Determine image type from filename prefix or suffix (e.g. image.jpg).
*/
assert(image_info != (ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image_info->filename != (char *) NULL);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
read_info=CloneImageInfo(image_info);
(void) CopyMagickString(magick_filename,read_info->filename,MaxTextExtent);
(void) SetImageInfo(read_info,0,exception);
(void) CopyMagickString(filename,read_info->filename,MaxTextExtent);
(void) CopyMagickString(magick,read_info->magick,MaxTextExtent);
domain=CoderPolicyDomain;
rights=ReadPolicyRights;
if (IsRightsAuthorized(domain,rights,read_info->magick) == MagickFalse)
{
errno=EPERM;
(void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
"NotAuthorized","`%s'",read_info->filename);
return((Image *) NULL);
}
/*
Call appropriate image reader based on image type.
*/
sans_exception=AcquireExceptionInfo();
magick_info=GetMagickInfo(read_info->magick,sans_exception);
sans_exception=DestroyExceptionInfo(sans_exception);
if (magick_info != (const MagickInfo *) NULL)
{
if (GetMagickEndianSupport(magick_info) == MagickFalse)
read_info->endian=UndefinedEndian;
else
if ((image_info->endian == UndefinedEndian) &&
(GetMagickRawSupport(magick_info) != MagickFalse))
{
size_t
lsb_first;
lsb_first=1;
read_info->endian=(*(char *) &lsb_first) == 1 ? LSBEndian :
MSBEndian;
}
}
if ((magick_info != (const MagickInfo *) NULL) &&
(GetMagickSeekableStream(magick_info) != MagickFalse))
{
MagickBooleanType
status;
image=AcquireImage(read_info,exception);
(void) CopyMagickString(image->filename,read_info->filename,
MaxTextExtent);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
read_info=DestroyImageInfo(read_info);
image=DestroyImage(image);
return((Image *) NULL);
}
if (IsBlobSeekable(image) == MagickFalse)
{
/*
Coder requires a seekable stream.
*/
*read_info->filename='\0';
status=ImageToFile(image,read_info->filename,exception);
if (status == MagickFalse)
{
(void) CloseBlob(image);
read_info=DestroyImageInfo(read_info);
image=DestroyImage(image);
return((Image *) NULL);
}
read_info->temporary=MagickTrue;
}
(void) CloseBlob(image);
image=DestroyImage(image);
}
image=NewImageList();
if (constitute_semaphore == (SemaphoreInfo *) NULL)
AcquireSemaphoreInfo(&constitute_semaphore);
if ((magick_info != (const MagickInfo *) NULL) &&
(GetImageDecoder(magick_info) != (DecodeImageHandler *) NULL))
{
thread_support=GetMagickThreadSupport(magick_info);
if ((thread_support & DecoderThreadSupport) == 0)
LockSemaphoreInfo(constitute_semaphore);
image=GetImageDecoder(magick_info)(read_info,exception);
if ((thread_support & DecoderThreadSupport) == 0)
UnlockSemaphoreInfo(constitute_semaphore);
}
else
{
delegate_info=GetDelegateInfo(read_info->magick,(char *) NULL,exception);
if (delegate_info == (const DelegateInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
read_info->filename);
if (read_info->temporary != MagickFalse)
(void) RelinquishUniqueFileResource(read_info->filename);
read_info=DestroyImageInfo(read_info);
return((Image *) NULL);
}
/*
Let our decoding delegate process the image.
*/
image=AcquireImage(read_info,exception);
if (image == (Image *) NULL)
{
read_info=DestroyImageInfo(read_info);
return((Image *) NULL);
}
(void) CopyMagickString(image->filename,read_info->filename,
MaxTextExtent);
*read_info->filename='\0';
if (GetDelegateThreadSupport(delegate_info) == MagickFalse)
LockSemaphoreInfo(constitute_semaphore);
(void) InvokeDelegate(read_info,image,read_info->magick,(char *) NULL,
exception);
if (GetDelegateThreadSupport(delegate_info) == MagickFalse)
UnlockSemaphoreInfo(constitute_semaphore);
image=DestroyImageList(image);
read_info->temporary=MagickTrue;
(void) SetImageInfo(read_info,0,exception);
magick_info=GetMagickInfo(read_info->magick,exception);
if ((magick_info == (const MagickInfo *) NULL) ||
(GetImageDecoder(magick_info) == (DecodeImageHandler *) NULL))
{
if (IsPathAccessible(read_info->filename) != MagickFalse)
(void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
read_info->filename);
else
ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
read_info->filename);
read_info=DestroyImageInfo(read_info);
return((Image *) NULL);
}
thread_support=GetMagickThreadSupport(magick_info);
if ((thread_support & DecoderThreadSupport) == 0)
LockSemaphoreInfo(constitute_semaphore);
image=(Image *) (GetImageDecoder(magick_info))(read_info,exception);
if ((thread_support & DecoderThreadSupport) == 0)
UnlockSemaphoreInfo(constitute_semaphore);
}
if (read_info->temporary != MagickFalse)
{
(void) RelinquishUniqueFileResource(read_info->filename);
read_info->temporary=MagickFalse;
if (image != (Image *) NULL)
(void) CopyMagickString(image->filename,filename,MaxTextExtent);
}
if (image == (Image *) NULL)
{
read_info=DestroyImageInfo(read_info);
return(image);
}
if (exception->severity >= ErrorException)
(void) LogMagickEvent(ExceptionEvent,GetMagickModule(),
"Coder (%s) generated an image despite an error (%d), "
"notify the developers",image->magick,exception->severity);
if (IsBlobTemporary(image) != MagickFalse)
(void) RelinquishUniqueFileResource(read_info->filename);
if ((GetNextImageInList(image) != (Image *) NULL) &&
(IsSceneGeometry(read_info->scenes,MagickFalse) != MagickFalse))
{
Image
*clones;
clones=CloneImages(image,read_info->scenes,exception);
if (clones == (Image *) NULL)
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"SubimageSpecificationReturnsNoImages","`%s'",read_info->filename);
else
{
image=DestroyImageList(image);
image=GetFirstImageInList(clones);
}
}
if (GetBlobError(image) != MagickFalse)
{
ThrowFileException(exception,FileOpenError,
"AnErrorHasOccurredReadingFromFile",read_info->filename);
image=DestroyImageList(image);
read_info=DestroyImageInfo(read_info);
return((Image *) NULL);
}
for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))
{
char
magick_path[MaxTextExtent],
*property,
timestamp[MaxTextExtent];
const char
*option;
const StringInfo
*profile;
next->taint=MagickFalse;
GetPathComponent(magick_filename,MagickPath,magick_path);
if (*magick_path == '\0')
(void) CopyMagickString(next->magick,magick,MaxTextExtent);
(void) CopyMagickString(next->magick_filename,magick_filename,
MaxTextExtent);
if (IsBlobTemporary(image) != MagickFalse)
(void) CopyMagickString(next->filename,filename,MaxTextExtent);
if (next->magick_columns == 0)
next->magick_columns=next->columns;
if (next->magick_rows == 0)
next->magick_rows=next->rows;
value=GetImageProperty(next,"tiff:Orientation",exception);
if (value == (char *) NULL)
value=GetImageProperty(next,"exif:Orientation",exception);
if (value != (char *) NULL)
{
next->orientation=(OrientationType) StringToLong(value);
(void) DeleteImageProperty(next,"tiff:Orientation");
(void) DeleteImageProperty(next,"exif:Orientation");
}
value=GetImageProperty(next,"exif:XResolution",exception);
if (value != (char *) NULL)
{
geometry_info.rho=next->resolution.x;
geometry_info.sigma=1.0;
flags=ParseGeometry(value,&geometry_info);
if (geometry_info.sigma != 0)
next->resolution.x=geometry_info.rho/geometry_info.sigma;
(void) DeleteImageProperty(next,"exif:XResolution");
}
value=GetImageProperty(next,"exif:YResolution",exception);
if (value != (char *) NULL)
{
geometry_info.rho=next->resolution.y;
geometry_info.sigma=1.0;
flags=ParseGeometry(value,&geometry_info);
if (geometry_info.sigma != 0)
next->resolution.y=geometry_info.rho/geometry_info.sigma;
(void) DeleteImageProperty(next,"exif:YResolution");
}
value=GetImageProperty(next,"tiff:ResolutionUnit",exception);
if (value == (char *) NULL)
value=GetImageProperty(next,"exif:ResolutionUnit",exception);
if (value != (char *) NULL)
{
next->units=(ResolutionType) (StringToLong(value)-1);
(void) DeleteImageProperty(next,"exif:ResolutionUnit");
(void) DeleteImageProperty(next,"tiff:ResolutionUnit");
}
if (next->page.width == 0)
next->page.width=next->columns;
if (next->page.height == 0)
next->page.height=next->rows;
option=GetImageOption(read_info,"caption");
if (option != (const char *) NULL)
{
property=InterpretImageProperties(read_info,next,option,exception);
(void) SetImageProperty(next,"caption",property,exception);
property=DestroyString(property);
}
option=GetImageOption(read_info,"comment");
if (option != (const char *) NULL)
{
property=InterpretImageProperties(read_info,next,option,exception);
(void) SetImageProperty(next,"comment",property,exception);
property=DestroyString(property);
}
option=GetImageOption(read_info,"label");
if (option != (const char *) NULL)
{
property=InterpretImageProperties(read_info,next,option,exception);
(void) SetImageProperty(next,"label",property,exception);
property=DestroyString(property);
}
if (LocaleCompare(next->magick,"TEXT") == 0)
(void) ParseAbsoluteGeometry("0x0+0+0",&next->page);
if ((read_info->extract != (char *) NULL) &&
(read_info->stream == (StreamHandler) NULL))
{
RectangleInfo
geometry;
flags=ParseAbsoluteGeometry(read_info->extract,&geometry);
if ((next->columns != geometry.width) ||
(next->rows != geometry.height))
{
if (((flags & XValue) != 0) || ((flags & YValue) != 0))
{
Image
*crop_image;
crop_image=CropImage(next,&geometry,exception);
if (crop_image != (Image *) NULL)
ReplaceImageInList(&next,crop_image);
}
else
if (((flags & WidthValue) != 0) || ((flags & HeightValue) != 0))
{
Image
*size_image;
flags=ParseRegionGeometry(next,read_info->extract,&geometry,
exception);
size_image=ResizeImage(next,geometry.width,geometry.height,
next->filter,next->blur,exception);
if (size_image != (Image *) NULL)
ReplaceImageInList(&next,size_image);
}
}
}
profile=GetImageProfile(next,"icc");
if (profile == (const StringInfo *) NULL)
profile=GetImageProfile(next,"icm");
profile=GetImageProfile(next,"iptc");
if (profile == (const StringInfo *) NULL)
profile=GetImageProfile(next,"8bim");
(void) FormatMagickTime(GetBlobProperties(next)->st_mtime,MaxTextExtent,
timestamp);
(void) SetImageProperty(next,"date:modify",timestamp,exception);
(void) FormatMagickTime(GetBlobProperties(next)->st_ctime,MaxTextExtent,
timestamp);
(void) SetImageProperty(next,"date:create",timestamp,exception);
option=GetImageOption(image_info,"delay");
if (option != (const char *) NULL)
{
GeometryInfo
geometry_info;
flags=ParseGeometry(option,&geometry_info);
if ((flags & GreaterValue) != 0)
{
if (next->delay > (size_t) floor(geometry_info.rho+0.5))
next->delay=(size_t) floor(geometry_info.rho+0.5);
}
else
if ((flags & LessValue) != 0)
{
if (next->delay < (size_t) floor(geometry_info.rho+0.5))
next->ticks_per_second=(ssize_t) floor(geometry_info.sigma+0.5);
}
else
next->delay=(size_t) floor(geometry_info.rho+0.5);
if ((flags & SigmaValue) != 0)
next->ticks_per_second=(ssize_t) floor(geometry_info.sigma+0.5);
}
option=GetImageOption(image_info,"dispose");
if (option != (const char *) NULL)
next->dispose=(DisposeType) ParseCommandOption(MagickDisposeOptions,
MagickFalse,option);
if (read_info->verbose != MagickFalse)
(void) IdentifyImage(next,stderr,MagickFalse,exception);
image=next;
}
read_info=DestroyImageInfo(read_info);
return(GetFirstImageInList(image));
}
int tc_filter(frame_list_t *ptr_, char *options)
{
vframe_list_t *ptr = (vframe_list_t *)ptr_;
int instance = ptr->filter_id;
Image *pattern, *resized, *orig = 0;
ImageInfo *image_info;
PixelPacket *pixel_packet;
pixelsMask *pixel_last;
ExceptionInfo exception_info;
if(ptr->tag & TC_FILTER_GET_CONFIG) {
char buf[128];
optstr_filter_desc(options, MOD_NAME, MOD_CAP, MOD_VERSION,
MOD_AUTHOR, "VRYMO", "1");
tc_snprintf(buf, 128, "/dev/null");
optstr_param(options, "pattern", "Pattern image file path", "%s", buf);
tc_snprintf(buf, 128, "results.dat");
optstr_param(options, "results", "Results file path" , "%s", buf);
tc_snprintf(buf, 128, "%f", compare[instance]->delta);
optstr_param(options, "delta", "Delta error", "%f",buf,"0.0", "100.0");
return 0;
}
//----------------------------------
//
// filter init
//
//----------------------------------
if(ptr->tag & TC_FILTER_INIT)
{
unsigned int t,r,index;
pixelsMask *temp;
compare[instance] = tc_malloc(sizeof(compareData));
if(compare[instance] == NULL)
return (-1);
compare[instance]->vob = tc_get_vob();
if(compare[instance]->vob ==NULL)
return(-1);
compare[instance]->delta=DELTA_COLOR;
compare[instance]->step=1;
compare[instance]->width=0;
compare[instance]->height=0;
compare[instance]->frames = 0;
compare[instance]->pixel_mask = NULL;
pixel_last = NULL;
compare[instance]->width = compare[instance]->vob->ex_v_width;
compare[instance]->height = compare[instance]->vob->ex_v_height;
if (options != NULL) {
char pattern_name[PATH_MAX];
char results_name[PATH_MAX];
memset(pattern_name,0,PATH_MAX);
memset(results_name,0,PATH_MAX);
if(verbose) tc_log_info(MOD_NAME, "options=%s", options);
optstr_get(options, "pattern", "%[^:]", pattern_name);
optstr_get(options, "results", "%[^:]", results_name);
optstr_get(options, "delta", "%f", &compare[instance]->delta);
if (verbose > 1) {
tc_log_info(MOD_NAME, "Compare Image Settings:");
tc_log_info(MOD_NAME, " pattern = %s\n", pattern_name);
tc_log_info(MOD_NAME, " results = %s\n", results_name);
tc_log_info(MOD_NAME, " delta = %f\n", compare[instance]->delta);
}
if (strlen(results_name) == 0) {
// Ponemos el nombre del fichero al original con extension dat
strlcpy(results_name, "/tmp/compare.dat", sizeof(results_name));
}
if (!(compare[instance]->results = fopen(results_name, "w")))
{
tc_log_perror(MOD_NAME, "could not open file for writing");
}
InitializeMagick("");
if (verbose > 1)
tc_log_info(MOD_NAME, "Magick Initialized successfully");
GetExceptionInfo(&exception_info);
image_info = CloneImageInfo ((ImageInfo *) NULL);
strlcpy(image_info->filename, pattern_name, MaxTextExtent);
if (verbose > 1)
tc_log_info(MOD_NAME, "Trying to open image");
orig = ReadImage(image_info,
&exception_info);
if (orig == (Image *) NULL) {
MagickWarning(exception_info.severity,
exception_info.reason,
exception_info.description);
strlcpy(pattern_name, "/dev/null", sizeof(pattern_name));
}else{
if (verbose > 1)
tc_log_info(MOD_NAME, "Image loaded successfully");
}
}
else{
tc_log_perror(MOD_NAME, "Not image provided");
}
if (options != NULL)
if (optstr_lookup (options, "help")) {
help_optstr();
}
fprintf(compare[instance]->results,"#fps:%f\n",compare[instance]->vob->fps);
if (orig != NULL){
// Flip and resize
if (compare[instance]->vob->im_v_codec == CODEC_YUV)
TransformRGBImage(orig,YCbCrColorspace);
if (verbose > 1) tc_log_info(MOD_NAME, "Resizing the Image");
resized = ResizeImage(orig,
compare[instance]->width,
compare[instance]->height,
GaussianFilter,
1,
&exception_info);
if (verbose > 1)
tc_log_info(MOD_NAME, "Flipping the Image");
pattern = FlipImage(resized, &exception_info);
if (pattern == (Image *) NULL) {
MagickError (exception_info.severity,
exception_info.reason,
exception_info.description);
}
// Filling the matrix with the pixels values not
// alpha
if (verbose > 1) tc_log_info(MOD_NAME, "GetImagePixels");
pixel_packet = GetImagePixels(pattern,0,0,
pattern->columns,
pattern->rows);
if (verbose > 1) tc_log_info(MOD_NAME, "Filling the Image matrix");
for (t = 0; t < pattern->rows; t++)
for (r = 0; r < pattern->columns; r++){
index = t*pattern->columns + r;
if (pixel_packet[index].opacity == 0){
temp=tc_malloc(sizeof(struct pixelsMask));
temp->row=t;
temp->col=r;
temp->r = (uint8_t)ScaleQuantumToChar(pixel_packet[index].red);
temp->g = (uint8_t)ScaleQuantumToChar(pixel_packet[index].green);
temp->b = (uint8_t)ScaleQuantumToChar(pixel_packet[index].blue);
temp->next=NULL;
if (pixel_last == NULL){
pixel_last = temp;
compare[instance]->pixel_mask = temp;
}else{
pixel_last->next = temp;
pixel_last = temp;
}
}
}
if (verbose)
tc_log_info(MOD_NAME, "%s %s",
MOD_VERSION, MOD_CAP);
}
return(0);
}
//----------------------------------
//
// filter close
//
//----------------------------------
if(ptr->tag & TC_FILTER_CLOSE) {
if (compare[instance] != NULL) {
fclose(compare[instance]->results);
free(compare[instance]);
}
DestroyMagick();
compare[instance]=NULL;
return(0);
} /* filter close */
//----------------------------------
//
// filter frame routine
//
//----------------------------------
// tag variable indicates, if we are called before
// transcodes internal video/audio frame processing routines
// or after and determines video/audio context
if((ptr->tag & TC_POST_M_PROCESS) && (ptr->tag & TC_VIDEO)) {
// For now I only support RGB color space
pixelsMask *item = NULL;
double sr,sg,sb;
double avg_dr,avg_dg,avg_db;
if (compare[instance]->vob->im_v_codec == CODEC_RGB){
int r,g,b,c;
double width_long;
if (compare[instance]->pixel_mask != NULL)
{
item = compare[instance]->pixel_mask;
c = 0;
sr = 0.0;
sg = 0.0;
sb = 0.0;
width_long = compare[instance]->width*3;
while(item){
r = item->row*width_long + item->col*3;
g = item->row*width_long
+ item->col*3 + 1;
b = item->row*width_long
+ item->col*3 + 2;
// diff between points
// Interchange RGB values if necesary
sr = sr + (double)abs((unsigned char)ptr->video_buf[r] - item->r);
sg = sg + (double)abs((unsigned char)ptr->video_buf[g] - item->g);
sb = sb + (double)abs((unsigned char)ptr->video_buf[b] - item->b);
item = item->next;
c++;
}
avg_dr = sr/(double)c;
avg_dg = sg/(double)c;
avg_db = sb/(double)c;
if ((avg_dr < compare[instance]->delta) && (avg_dg < compare[instance]->delta) && (avg_db < compare[instance]->delta))
fprintf(compare[instance]->results,"1");
else
fprintf(compare[instance]->results,"n");
fflush(compare[instance]->results);
}
compare[instance]->frames++;
return(0);
}else{
// The colospace is YUV
// FIXME: Doesn't works, I need to code all this part
// again
int Y,Cr,Cb,c;
if (compare[instance]->pixel_mask != NULL)
{
item = compare[instance]->pixel_mask;
c = 0;
sr = 0.0;
sg = 0.0;
sb = 0.0;
while(item){
Y = item->row*compare[instance]->width + item->col;
Cb = compare[instance]->height*compare[instance]->width
+ (int)((item->row*compare[instance]->width + item->col)/4);
Cr = compare[instance]->height*compare[instance]->width
+ (int)((compare[instance]->height*compare[instance]->width)/4)
+ (int)((item->row*compare[instance]->width + item->col)/4);
// diff between points
// Interchange RGB values if necesary
sr = sr + (double)abs((unsigned char)ptr->video_buf[Y] - item->r);
sg = sg + (double)abs((unsigned char)ptr->video_buf[Cb] - item->g);
sb = sb + (double)abs((unsigned char)ptr->video_buf[Cr] - item->b);
item = item->next;
c++;
}
avg_dr = sr/(double)c;
avg_dg = sg/(double)c;
avg_db = sb/(double)c;
if ((avg_dr < compare[instance]->delta) && (avg_dg < compare[instance]->delta) && (avg_db < compare[instance]->delta))
fprintf(compare[instance]->results,"1");
else
fprintf(compare[instance]->results,"n");
}
compare[instance]->frames++;
return(0);
}
}
return(0);
}
static void create_level(Image *image, char *type, int level,
unsigned long width, unsigned long height,
unsigned int columns, unsigned int rows)
{
int i;
unsigned int row = 0;
unsigned int col = 0;
unsigned int xoff = 0;
unsigned int yoff = 0;
char dname[NAME_MAX + 1];
Image *rimage;
ImageInfo *image_info;
ExceptionInfo exception;
RectangleInfo cropper;
GetExceptionInfo(&exception);
image_info = CloneImageInfo((ImageInfo *)NULL);
rimage = ResizeImage(image, width, height, LanczosFilter, 1.0,
&exception);
memset(&cropper, 0, sizeof(cropper));
snprintf(dname, NAME_MAX + 1, "%d", level);
mkdir(dname, 0777);
/* We create the tiles by columns */
for (i = 0; i < columns * rows; i++) {
Image *tile;
if (i % rows == 0 && i != 0) {
/* Start a new column */
col++;
row = 0;
xoff = col * TILE_SZ;
yoff = 0;
}
/*
* A lot of the complexity here is to cater for having
* overlap in the tiles.
*/
/* Are we the top left tile? */
if (col == 0 && row == 0) {
cropper.width = TILE_SZ + OVERLAP;
cropper.height = TILE_SZ + OVERLAP;
/* Are we the top right tile? */
} else if (col == columns - 1 && row == 0) {
cropper.width = TILE_SZ + OVERLAP;
cropper.height = TILE_SZ + OVERLAP;
cropper.x = xoff - OVERLAP;
cropper.y = yoff;
/* Are we the bottom left tile? */
} else if (col == 0 && row == rows - 1) {
cropper.width = TILE_SZ + OVERLAP;
cropper.height = TILE_SZ + OVERLAP;
cropper.y = yoff - OVERLAP;
/* Are we the bottom right tile? */
} else if (col == columns - 1 && row == rows - 1) {
cropper.width = TILE_SZ + OVERLAP;
cropper.height = TILE_SZ + OVERLAP;
cropper.x = xoff - OVERLAP;
cropper.y = yoff - OVERLAP;
/* Are we on the top edge? */
} else if (row == 0) {
cropper.width = TILE_SZ + (OVERLAP * 2);
cropper.height = TILE_SZ + OVERLAP;
cropper.x = xoff - OVERLAP;
cropper.y = yoff;
/* Are we on the bottom edge? */
} else if (row == rows - 1) {
cropper.width = TILE_SZ + (OVERLAP * 2);
cropper.height = TILE_SZ + OVERLAP;
cropper.x = xoff - OVERLAP;
cropper.y = yoff - OVERLAP;
/* Are we on the left hand edge? */
} else if (col == 0) {
cropper.width = TILE_SZ + OVERLAP;
cropper.height = TILE_SZ + (OVERLAP * 2);
cropper.y = yoff - OVERLAP;
/* Are we on the right hand edge? */
} else if (col == columns - 1) {
cropper.width = TILE_SZ + OVERLAP;
cropper.height = TILE_SZ + (OVERLAP * 2);
cropper.x = xoff - OVERLAP;
cropper.y = yoff - OVERLAP;
/* We are an internal tile */
} else {
cropper.width = TILE_SZ + (OVERLAP * 2);
cropper.height = TILE_SZ + (OVERLAP * 2);
cropper.x = xoff - OVERLAP;
cropper.y = yoff - OVERLAP;
}
tile = CropImage(rimage, &cropper, &exception);
snprintf(tile->filename, sizeof(tile->filename), "%d/%u_%u.%s",
level, col, row, type);
WriteImage(image_info, tile);
DestroyImage(tile);
/* Adjust the y (height) offset for the next row */
yoff += TILE_SZ;
row++;
}
DestroyImage(rimage);
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d Y U V I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadYUVImage() reads an image with digital YUV (CCIR 601 4:1:1, plane
% or partition interlaced, or 4:2:2 plane, partition interlaced or
% noninterlaced) bytes and returns it. It allocates the memory necessary
% for the new Image structure and returns a pointer to the new image.
%
% The format of the ReadYUVImage method is:
%
% Image *ReadYUVImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadYUVImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
Image
*chroma_image,
*image,
*resize_image;
InterlaceType
interlace;
MagickBooleanType
status;
register const PixelPacket
*chroma_pixels;
register ssize_t
x;
register PixelPacket
*q;
register unsigned char
*p;
ssize_t
count,
horizontal_factor,
vertical_factor,
y;
size_t
quantum;
unsigned char
*scanline;
/*
Allocate image structure.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(OptionError,"MustSpecifyImageSize");
status=SetImageExtent(image,image->columns,image->rows);
if (status == MagickFalse)
{
InheritException(exception,&image->exception);
return(DestroyImageList(image));
}
quantum=(size_t) (image->depth <= 8 ? 1 : 2);
interlace=image_info->interlace;
horizontal_factor=2;
vertical_factor=2;
if (image_info->sampling_factor != (char *) NULL)
{
GeometryInfo
geometry_info;
MagickStatusType
flags;
flags=ParseGeometry(image_info->sampling_factor,&geometry_info);
horizontal_factor=(ssize_t) geometry_info.rho;
vertical_factor=(ssize_t) geometry_info.sigma;
if ((flags & SigmaValue) == 0)
vertical_factor=horizontal_factor;
if ((horizontal_factor != 1) && (horizontal_factor != 2) &&
(vertical_factor != 1) && (vertical_factor != 2))
ThrowReaderException(CorruptImageError,"UnexpectedSamplingFactor");
}
if ((interlace == UndefinedInterlace) ||
((interlace == NoInterlace) && (vertical_factor == 2)))
{
interlace=NoInterlace; /* CCIR 4:2:2 */
if (vertical_factor == 2)
interlace=PlaneInterlace; /* CCIR 4:1:1 */
}
if (interlace != PartitionInterlace)
{
/*
Open image file.
*/
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
if (DiscardBlobBytes(image,(MagickSizeType) image->offset) == MagickFalse)
ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
image->filename);
}
/*
Allocate memory for a scanline.
*/
if (interlace == NoInterlace)
scanline=(unsigned char *) AcquireQuantumMemory((size_t) 2UL*
image->columns+2UL,quantum*sizeof(*scanline));
else
scanline=(unsigned char *) AcquireQuantumMemory(image->columns,
quantum*sizeof(*scanline));
if (scanline == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
do
{
chroma_image=CloneImage(image,(image->columns + horizontal_factor - 1) /
horizontal_factor, (image->rows + vertical_factor - 1) / vertical_factor,
MagickTrue,exception);
if (chroma_image == (Image *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
/*
Convert raster image to pixel packets.
*/
if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
if (image->scene >= (image_info->scene+image_info->number_scenes-1))
break;
status=SetImageExtent(image,image->columns,image->rows);
if (status == MagickFalse)
{
InheritException(exception,&image->exception);
return(DestroyImageList(image));
}
if (interlace == PartitionInterlace)
{
AppendImageFormat("Y",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
}
for (y=0; y < (ssize_t) image->rows; y++)
{
register PixelPacket
*chroma_pixels;
if (interlace == NoInterlace)
{
if ((y > 0) || (GetPreviousImageInList(image) == (Image *) NULL))
(void) ReadBlob(image,(size_t) (2*quantum*image->columns),scanline);
p=scanline;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
chroma_pixels=QueueAuthenticPixels(chroma_image,0,y,
chroma_image->columns,1,exception);
if (chroma_pixels == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x+=2)
{
SetPixelRed(chroma_pixels,0);
if (quantum == 1)
SetPixelGreen(chroma_pixels,ScaleCharToQuantum(*p++));
else
{
SetPixelGreen(chroma_pixels,ScaleShortToQuantum(((*p) << 8) |
*(p+1)));
p+=2;
}
if (quantum == 1)
SetPixelRed(q,ScaleCharToQuantum(*p++));
else
{
SetPixelRed(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));
p+=2;
}
SetPixelGreen(q,0);
SetPixelBlue(q,0);
q++;
SetPixelGreen(q,0);
SetPixelBlue(q,0);
if (quantum == 1)
SetPixelBlue(chroma_pixels,ScaleCharToQuantum(*p++));
else
{
SetPixelBlue(chroma_pixels,ScaleShortToQuantum(((*p) << 8) |
*(p+1)));
p+=2;
}
if (quantum == 1)
SetPixelRed(q,ScaleCharToQuantum(*p++));
else
{
SetPixelRed(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));
p+=2;
}
chroma_pixels++;
q++;
}
}
else
{
if ((y > 0) || (GetPreviousImageInList(image) == (Image *) NULL))
(void) ReadBlob(image,(size_t) quantum*image->columns,scanline);
p=scanline;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
if (quantum == 1)
SetPixelRed(q,ScaleCharToQuantum(*p++));
else
{
SetPixelRed(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));
p+=2;
}
SetPixelGreen(q,0);
SetPixelBlue(q,0);
q++;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (interlace == NoInterlace)
if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
}
if (interlace == PartitionInterlace)
{
(void) CloseBlob(image);
AppendImageFormat("U",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
}
if (interlace != NoInterlace)
{
for (y=0; y < (ssize_t) chroma_image->rows; y++)
{
(void) ReadBlob(image,(size_t) quantum*chroma_image->columns,scanline);
p=scanline;
q=QueueAuthenticPixels(chroma_image,0,y,chroma_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) chroma_image->columns; x++)
{
SetPixelRed(q,0);
if (quantum == 1)
SetPixelGreen(q,ScaleCharToQuantum(*p++));
else
{
SetPixelGreen(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));
p+=2;
}
SetPixelBlue(q,0);
q++;
}
if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
break;
}
if (interlace == PartitionInterlace)
{
(void) CloseBlob(image);
AppendImageFormat("V",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
}
for (y=0; y < (ssize_t) chroma_image->rows; y++)
{
(void) ReadBlob(image,(size_t) quantum*chroma_image->columns,scanline);
p=scanline;
q=GetAuthenticPixels(chroma_image,0,y,chroma_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) chroma_image->columns; x++)
{
if (quantum == 1)
SetPixelBlue(q,ScaleCharToQuantum(*p++));
else
{
SetPixelBlue(q,ScaleShortToQuantum(((*p) << 8) | *(p+1)));
p+=2;
}
q++;
}
if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
break;
}
}
/*
Scale image.
*/
resize_image=ResizeImage(chroma_image,image->columns,image->rows,
TriangleFilter,1.0,exception);
chroma_image=DestroyImage(chroma_image);
if (resize_image == (Image *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (y=0; y < (ssize_t) image->rows; y++)
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
chroma_pixels=GetVirtualPixels(resize_image,0,y,resize_image->columns,1,
&resize_image->exception);
if ((q == (PixelPacket *) NULL) ||
(chroma_pixels == (const PixelPacket *) NULL))
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelGreen(q,GetPixelGreen(chroma_pixels));
SetPixelBlue(q,GetPixelBlue(chroma_pixels));
chroma_pixels++;
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
resize_image=DestroyImage(resize_image);
SetImageColorspace(image,YCbCrColorspace);
if (interlace == PartitionInterlace)
(void) CopyMagickString(image->filename,image_info->filename,
MaxTextExtent);
if (EOFBlob(image) != MagickFalse)
{
ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
image->filename);
break;
}
/*
Proceed to next image.
*/
if (image_info->number_scenes != 0)
if (image->scene >= (image_info->scene+image_info->number_scenes-1))
break;
if (interlace == NoInterlace)
count=ReadBlob(image,(size_t) (2*quantum*image->columns),scanline);
else
count=ReadBlob(image,(size_t) quantum*image->columns,scanline);
if (count != 0)
{
/*
Allocate next image structure.
*/
AcquireNextImage(image_info,image);
if (GetNextImageInList(image) == (Image *) NULL)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
image=SyncNextImageInList(image);
status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
GetBlobSize(image));
if (status == MagickFalse)
break;
}
} while (count != 0);
scanline=(unsigned char *) RelinquishMagickMemory(scanline);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
ngx_int_t
convert_image(ngx_http_request_t *r, convert_options_t *option_info,
Image **image)
{
ngx_uint_t i;
ngx_http_gm_convert_option_t *options;
ngx_http_gm_convert_option_t *option;
RectangleInfo geometry;
RectangleInfo geometry_info;
ExceptionInfo exception;
Image *resize_image = NULL;
u_char *resize_geometry = NULL;
u_char *need_crop_resize = NULL;
Image *rotate_image = NULL;
u_char *rotate_degrees = NULL;
ngx_int_t degrees;
ngx_int_t degrees_suffix_len = 0;
dd("entering");
options = option_info->options->elts;
for (i = 0; i < option_info->options->nelts; ++i) {
option = &options[i];
if (option->type == NGX_HTTP_GM_RESIZE_OPTION) {
dd("starting resize");
resize_geometry = ngx_http_gm_get_str_value(r,
option->resize_geometry_cv, &option->resize_geometry);
need_crop_resize = (u_char *)ngx_strchr(resize_geometry, 'c');
if (need_crop_resize != NULL) {
*need_crop_resize = '^';
}
if (resize_geometry == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gm filter: resize image, get resize geometry failed");
return NGX_ERROR;
}
if (ngx_strncmp(resize_geometry, "no", 2) == 0) {
continue;
}
(void) GetImageGeometry(*image, (char *)resize_geometry, 1,
&geometry);
if ((geometry.width == (*image)->columns) &&
(geometry.height == (*image)->rows))
continue;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"resize image geometry: \"%s\"", resize_geometry);
GetExceptionInfo(&exception);
resize_image = ResizeImage(*image, geometry.width, geometry.height,
(*image)->filter,(*image)->blur, &exception);
if (resize_image == (Image *) NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gm filter: resize image failed, "
"arg: \"%s\" severity: \"%O\" "
"reason: \"%s\", description: \"%s\"",
resize_geometry, exception.severity,
exception.reason, exception.description);
DestroyExceptionInfo(&exception);
return NGX_ERROR;
}
DestroyImage(*image);
*image = resize_image;
DestroyExceptionInfo(&exception);
if (need_crop_resize != NULL) {
GetGeometry((char *)resize_geometry,
&geometry_info.x, &geometry_info.y,
(unsigned long *)(&geometry_info.width),
(unsigned long *)(&geometry_info.height));
if (geometry_info.width > (*image)->columns ||
geometry_info.height > (*image)->rows) {
continue;
}
geometry_info.x = ((*image)->columns - geometry_info.width) / 2;
geometry_info.y = ((*image)->rows - geometry_info.height) / 2;
GetExceptionInfo(&exception);
resize_image = CropImage(*image, &geometry_info, &exception);
if (resize_image == (Image *) NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gm filter: resize croping image failed, "
"arg: \"%s\" severity: \"%O\" "
"reason: \"%s\", description: \"%s\"",
resize_geometry, exception.severity,
exception.reason, exception.description);
DestroyExceptionInfo(&exception);
return NGX_ERROR;
}
DestroyImage(*image);
*image = resize_image;
DestroyExceptionInfo(&exception);
}
} else if (option->type == NGX_HTTP_GM_ROTATE_OPTION) {
dd("starting rotate");
rotate_degrees = ngx_http_gm_get_str_value(r,
option->rotate_degrees_cv, &option->rotate_degrees);
if (rotate_degrees == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gm filter: rotate image, get rotate degrees failed");
return NGX_ERROR;
}
if (ngx_strchr(rotate_degrees,'>') != (char *) NULL) {
if ((*image)->columns <= (*image)->rows)
continue;
degrees_suffix_len = 1;
}
if (ngx_strchr(rotate_degrees,'<') != (char *) NULL) {
if ((*image)->columns >= (*image)->rows)
continue;
degrees_suffix_len = 1;
}
degrees = 0;
degrees = ngx_atoi(rotate_degrees,
ngx_strlen(rotate_degrees) - degrees_suffix_len);
if (degrees == 0) {
continue;
}
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"rotate image degrees: \"%O\"", degrees);
GetExceptionInfo(&exception);
rotate_image=RotateImage(*image, degrees, &exception);
if (rotate_image == (Image *) NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gm filter: rotate image failed, "
"degrees: \"%s\" severity: \"%O\" "
"reason: \"%s\", description: \"%s\"",
option->rotate_degrees, exception.severity,
exception.reason, exception.description);
DestroyExceptionInfo(&exception);
return NGX_ERROR;
}
DestroyImage(*image);
*image = rotate_image;
DestroyExceptionInfo(&exception);
} else {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gm filter: convert command, unkonwn option");
return NGX_ERROR;
}
}
return NGX_OK;
}
//Show ROI Image,and Save ROI Image and it's coordinates
void Harrlike::SaveROI(IplImage *Img,CvSeq *faces)
{
CvSize new_size = cvSize(m_width,m_height);
CvRect ROI;
double Ratio = Img->width/1000.;
double m,angle;
int ratioX = 2,ratioY = 2;
//Rotate
if((m_TraningCoord[7].x - m_TraningCoord[1].x)!=0)
{
m = static_cast<double>(m_TraningCoord[7].y - m_TraningCoord[1].y)/(m_TraningCoord[7].x - m_TraningCoord[1].x);
angle = atan(m)*57.25972;
}
else
{
angle = 0;
}
CvPoint2D32f src_center = cvPoint2D32f(m_TraningCoord[1].x*1.0, m_TraningCoord[1].y*1.0);
float map[6];
CvMat rot_mat = cvMat( 2, 3, CV_32F,map);
cv2DRotationMatrix( src_center, angle,1.0, &rot_mat);
IplImage* dst = cvCreateImage(cvSize(Img->width,Img->height),8,1);
cvWarpAffine(Img, dst, &rot_mat);
//cvShowImage("2",dst);
//cvWaitKey(0);
double Coord3X = m_TraningCoord[3].x*cvGetReal2D(&rot_mat,0,0) + m_TraningCoord[3].y*cvGetReal2D(&rot_mat,0,1) + cvGetReal2D(&rot_mat,0,2)*1.0;
double Coord3Y = m_TraningCoord[3].x*cvGetReal2D(&rot_mat,1,0) + m_TraningCoord[3].y*cvGetReal2D(&rot_mat,1,1) + cvGetReal2D(&rot_mat,1,2)*1.0;
double Coord9X = m_TraningCoord[9].x*cvGetReal2D(&rot_mat,0,0) + m_TraningCoord[9].y*cvGetReal2D(&rot_mat,0,1) + cvGetReal2D(&rot_mat,0,2)*1.0;
double Coord9Y = m_TraningCoord[9].x*cvGetReal2D(&rot_mat,1,0) + m_TraningCoord[9].y*cvGetReal2D(&rot_mat,1,1) + cvGetReal2D(&rot_mat,1,2)*1.0;
double Coord1X = m_TraningCoord[1].x*cvGetReal2D(&rot_mat,0,0) + m_TraningCoord[1].y*cvGetReal2D(&rot_mat,0,1) + cvGetReal2D(&rot_mat,0,2)*1.0;
double Coord0Y = m_TraningCoord[0].x*cvGetReal2D(&rot_mat,1,0) + m_TraningCoord[0].y*cvGetReal2D(&rot_mat,1,1) + cvGetReal2D(&rot_mat,1,2)*1.0;
//鼻子中間
double middleX = (Coord3X + Coord9X)*0.5;
double middleY = (Coord3Y + Coord9Y)*0.5;
//取人臉出來
ROI.x = Coord1X;
ROI.y = Coord0Y;
ROI.width = (middleX-ROI.x)*ratioX;//600
ROI.height = (middleY - Coord0Y)*ratioY;//m_TraningCoord[11].y-m_TraningCoord[0].y
cvSetImageROI(dst, ROI);
ResizeImage(dst,new_size);
/*double multipleX = (m_width*1.0/ROI.width*1.0);
double multipleY = (m_height*1.0/ROI.height*1.0);
FILE *NormalizeCoord = fopen("..\\DataBase\\NormalizeCoord.xls","a");
for(int i = 0;i < 12;i++)
{
int normalizeX = (m_TraningCoord[i].x - ROI.x)*multipleX;
int normalizeY = (m_TraningCoord[i].y - ROI.y)*multipleY;
if(normalizeX > m_width) normalizeX = m_width;
if(normalizeY > m_height) normalizeY = m_height;
if(normalizeX < 0) normalizeX = 0;
if(normalizeY < 0) normalizeY = 0;
fprintf(NormalizeCoord,"%d\t%d\t",normalizeX,normalizeY);
}
fprintf(NormalizeCoord,"\n");
fclose(NormalizeCoord);*/
FILE *Coord = fopen("..\\DataBase\\Coordinate.xls","a");
for(int i = 0;i < 12;i++)
{
fprintf(Coord,"%d\t%d\t",m_TraningCoord[i].x,m_TraningCoord[i].y);
}
fprintf(Coord,"\n");
fclose(Coord);
//cvReleaseImage(&Img);
//cvSaveImage(filename,Img);
//cvShowImage("roi",Img);
//cvWaitKey(0);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e Y U V I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteYUVImage() writes an image to a file in the digital YUV
% (CCIR 601 4:1:1, plane or partition interlaced, or 4:2:2 plane, partition
% interlaced or noninterlaced) bytes and returns it.
%
% The format of the WriteYUVImage method is:
%
% MagickBooleanType WriteYUVImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o image_info: the image info.
%
% o image: The image.
%
*/
static MagickBooleanType WriteYUVImage(const ImageInfo *image_info,Image *image)
{
Image
*chroma_image,
*yuv_image;
InterlaceType
interlace;
MagickBooleanType
status;
MagickOffsetType
scene;
register const PixelPacket
*p,
*s;
register ssize_t
x;
size_t
height,
quantum,
width;
ssize_t
horizontal_factor,
vertical_factor,
y;
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
quantum=(size_t) (image->depth <= 8 ? 1 : 2);
interlace=image->interlace;
horizontal_factor=2;
vertical_factor=2;
if (image_info->sampling_factor != (char *) NULL)
{
GeometryInfo
geometry_info;
MagickStatusType
flags;
flags=ParseGeometry(image_info->sampling_factor,&geometry_info);
horizontal_factor=(ssize_t) geometry_info.rho;
vertical_factor=(ssize_t) geometry_info.sigma;
if ((flags & SigmaValue) == 0)
vertical_factor=horizontal_factor;
if ((horizontal_factor != 1) && (horizontal_factor != 2) &&
(vertical_factor != 1) && (vertical_factor != 2))
ThrowWriterException(CorruptImageError,"UnexpectedSamplingFactor");
}
if ((interlace == UndefinedInterlace) ||
((interlace == NoInterlace) && (vertical_factor == 2)))
{
interlace=NoInterlace; /* CCIR 4:2:2 */
if (vertical_factor == 2)
interlace=PlaneInterlace; /* CCIR 4:1:1 */
}
if (interlace != PartitionInterlace)
{
/*
Open output image file.
*/
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
}
else
{
AppendImageFormat("Y",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
}
scene=0;
do
{
/*
Sample image to an even width and height, if necessary.
*/
image->depth=(size_t) (quantum == 1 ? 8 : 16);
width=image->columns+(image->columns & (horizontal_factor-1));
height=image->rows+(image->rows & (vertical_factor-1));
yuv_image=ResizeImage(image,width,height,TriangleFilter,1.0,
&image->exception);
if (yuv_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,image->exception.reason);
(void) TransformImageColorspace(yuv_image,YCbCrColorspace);
/*
Downsample image.
*/
chroma_image=ResizeImage(image,width/horizontal_factor,
height/vertical_factor,TriangleFilter,1.0,&image->exception);
if (chroma_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,image->exception.reason);
(void) TransformImageColorspace(chroma_image,YCbCrColorspace);
if (interlace == NoInterlace)
{
/*
Write noninterlaced YUV.
*/
for (y=0; y < (ssize_t) yuv_image->rows; y++)
{
p=GetVirtualPixels(yuv_image,0,y,yuv_image->columns,1,
&yuv_image->exception);
if (p == (const PixelPacket *) NULL)
break;
s=GetVirtualPixels(chroma_image,0,y,chroma_image->columns,1,
&chroma_image->exception);
if (s == (const PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) yuv_image->columns; x++)
{
if (quantum == 1)
{
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetPixelGreen(s)));
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(p)));
p++;
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelBlue(s)));
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(p)));
}
else
{
(void) WriteBlobByte(image,ScaleQuantumToChar(
GetPixelGreen(s)));
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelRed(p)));
p++;
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelBlue(s)));
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelRed(p)));
}
p++;
s++;
x++;
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
}
yuv_image=DestroyImage(yuv_image);
}
else
{
/*
Initialize Y channel.
*/
for (y=0; y < (ssize_t) yuv_image->rows; y++)
{
p=GetVirtualPixels(yuv_image,0,y,yuv_image->columns,1,
&yuv_image->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) yuv_image->columns; x++)
{
if (quantum == 1)
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(p)));
else
(void) WriteBlobShort(image,ScaleQuantumToShort(GetPixelRed(p)));
p++;
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
}
yuv_image=DestroyImage(yuv_image);
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,1,3);
if (status == MagickFalse)
break;
}
/*
Initialize U channel.
*/
if (interlace == PartitionInterlace)
{
(void) CloseBlob(image);
AppendImageFormat("U",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,
&image->exception);
if (status == MagickFalse)
return(status);
}
for (y=0; y < (ssize_t) chroma_image->rows; y++)
{
p=GetVirtualPixels(chroma_image,0,y,chroma_image->columns,1,
&chroma_image->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) chroma_image->columns; x++)
{
if (quantum == 1)
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelGreen(p)));
else
(void) WriteBlobShort(image,ScaleQuantumToShort(
GetPixelGreen(p)));
p++;
}
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,2,3);
if (status == MagickFalse)
break;
}
/*
Initialize V channel.
*/
if (interlace == PartitionInterlace)
{
(void) CloseBlob(image);
AppendImageFormat("V",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,
&image->exception);
if (status == MagickFalse)
return(status);
}
for (y=0; y < (ssize_t) chroma_image->rows; y++)
{
p=GetVirtualPixels(chroma_image,0,y,chroma_image->columns,1,
&chroma_image->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) chroma_image->columns; x++)
{
if (quantum == 1)
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelBlue(p)));
else
(void) WriteBlobShort(image,ScaleQuantumToShort(GetPixelBlue(p)));
p++;
}
}
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,2,3);
if (status == MagickFalse)
break;
}
}
chroma_image=DestroyImage(chroma_image);
if (interlace == PartitionInterlace)
(void) CopyMagickString(image->filename,image_info->filename,
MaxTextExtent);
if (GetNextImageInList(image) == (Image *) NULL)
break;
image=SyncNextImageInList(image);
status=SetImageProgress(image,SaveImagesTag,scene++,
GetImageListLength(image));
if (status == MagickFalse)
break;
} while (image_info->adjoin != MagickFalse);
(void) CloseBlob(image);
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e H R Z I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WriteHRZImage() writes an image to a file in HRZ X image format.
%
% The format of the WriteHRZImage method is:
%
% MagickBooleanType WriteHRZImage(const ImageInfo *image_info,
% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
% o image_info: the image info.
%
% o image: The image.
%
% o exception: return any errors or warnings in this structure.
%
*/
static MagickBooleanType WriteHRZImage(const ImageInfo *image_info,Image *image,
ExceptionInfo *exception)
{
Image
*hrz_image;
MagickBooleanType
status;
register const Quantum
*p;
register ssize_t
x,
y;
register unsigned char
*q;
ssize_t
count;
unsigned char
*pixels;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
hrz_image=ResizeImage(image,256,240,image->filter,exception);
if (hrz_image == (Image *) NULL)
return(MagickFalse);
(void) TransformImageColorspace(hrz_image,sRGBColorspace,exception);
/*
Allocate memory for pixels.
*/
pixels=(unsigned char *) AcquireQuantumMemory((size_t) hrz_image->columns,
3*sizeof(*pixels));
if (pixels == (unsigned char *) NULL)
{
hrz_image=DestroyImage(hrz_image);
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
}
/*
Convert MIFF to HRZ raster pixels.
*/
for (y=0; y < (ssize_t) hrz_image->rows; y++)
{
p=GetVirtualPixels(hrz_image,0,y,hrz_image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
q=pixels;
for (x=0; x < (ssize_t) hrz_image->columns; x++)
{
*q++=ScaleQuantumToChar(GetPixelRed(hrz_image,p)/4);
*q++=ScaleQuantumToChar(GetPixelGreen(hrz_image,p)/4);
*q++=ScaleQuantumToChar(GetPixelBlue(hrz_image,p)/4);
p+=GetPixelChannels(hrz_image);
}
count=WriteBlob(image,(size_t) (q-pixels),pixels);
if (count != (ssize_t) (q-pixels))
break;
status=SetImageProgress(image,SaveImageTag,y,hrz_image->rows);
if (status == MagickFalse)
break;
}
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
hrz_image=DestroyImage(hrz_image);
(void) CloseBlob(image);
return(MagickTrue);
}
static ngx_int_t
ngx_screenshot_handler(ngx_http_request_t *r)
{
size_t len;
u_char *p;
ngx_buf_t *b;
ngx_chain_t cl;
u_char path[1024];
ExceptionInfo *exception;
Image *image = 0, *resized = 0;
ImageInfo *image_info = 0;
unsigned char *image_data;
ngx_str_t size;
ngx_int_t width = -1, height = -1;
ngx_screenshot_sizes_conf_t *screenshot_sizes_conf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_screenshot_module);
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "TEST %d", screenshot_sizes_conf->sizes.nelts);
//TODO: generate unique name
system("avconv -analyzeduration 1000 -i \"rtmp://127.0.0.1:1935\" -vframes 1 -q:v 2 -f image2 /tmp/output.png -loglevel quiet");
MagickCoreGenesis("", MagickTrue);
exception = AcquireExceptionInfo();
ngx_memzero(path, sizeof(path));
strcpy((char *)path, "/tmp/output.png");
image_info = CloneImageInfo((ImageInfo *)NULL);
strcpy(image_info->filename, (const char*)path);
image = ReadImage(image_info, exception);
if (image == 0) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to open screenshot file");
goto error;
}
if (ngx_http_arg(r, (u_char *) "size", sizeof("size") - 1, &size) == NGX_OK) {
if (size.len > 0) {
if (size.data[0] == 'l' && size.data[1] == 'o' && size.data[2] == 'w') {
width = 320;
height = 180;
}
else if (size.data[0] == 'm' && size.data[1] == 'e' && size.data[2] == 'd') {
width = 640;
height = 360;
}
else if (size.data[0] == 'h' && size.data[1] == 'i') {
width = 960;
height = 540;
}
else if (size.data[0] == 'h' && size.data[1] == 'd') {
width = 1280;
height = 720;
}
}
}
if (width < 1 || width > (ngx_int_t)image->columns) {
width = image->columns;
}
if (height < 1 || height > (ngx_int_t)image->rows) {
height = image->rows;
}
if (width == (ngx_int_t)image->columns && height == (ngx_int_t)image->rows) {
resized = image;
}
else {
resized = ResizeImage(image, width, height, SincFilter, 1.0, exception);
}
if (resized == 0) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to resize screenshot file");
goto error;
}
image_data = ImageToBlob(image_info, resized, &len, exception);
p = ngx_palloc(r->connection->pool, len);
if (p == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to allocate memory for response");
goto error;
}
ngx_memcpy(p, image_data, len);
if (resized != image) {
DestroyImage(resized);
}
DestroyImage(image);
MagicComponentTerminus();
ngx_str_set(&r->headers_out.content_type, "image/png");
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = len;
b = ngx_calloc_buf(r->pool);
if (b == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to allocate memory for response");
goto error;
}
b->start = b->pos = p;
b->end = b->last = p + len;
b->temporary = 1;
b->last_buf = 1;
ngx_memzero(&cl, sizeof(cl));
cl.buf = b;
ngx_http_send_header(r);
return ngx_http_output_filter(r, &cl);
error:
if (resized && resized != image) DestroyImage(resized);
if (image) DestroyImage(image);
MagicComponentTerminus();
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
/*
* Initialization function for an X Athena Widget module to Angband
*
* We should accept "-d<dpy>" requests in the "argv" array. XXX XXX XXX
*/
errr init_xaw(int argc, char **argv)
{
int i;
Widget topLevel;
Display *dpy;
cptr dpy_name = "";
#ifdef USE_GRAPHICS
cptr bitmap_file = "";
char filename[1024];
int pict_wid = 0;
int pict_hgt = 0;
char *TmpData;
#endif /* USE_GRAPHICS */
/* Parse args */
for (i = 1; i < argc; i++)
{
if (prefix(argv[i], "-d"))
{
dpy_name = &argv[i][2];
continue;
}
#ifdef USE_GRAPHICS
if (prefix(argv[i], "-s"))
{
smoothRescaling = FALSE;
continue;
}
if (prefix(argv[i], "-o"))
{
arg_graphics = GRAPHICS_ORIGINAL;
continue;
}
if (prefix(argv[i], "-a"))
{
arg_graphics = GRAPHICS_ADAM_BOLT;
continue;
}
if (prefix(argv[i], "-g"))
{
smoothRescaling = FALSE;
arg_graphics = GRAPHICS_DAVID_GERVAIS;
continue;
}
if (prefix(argv[i], "-b"))
{
use_bigtile = TRUE;
continue;
}
#endif /* USE_GRAPHICS */
if (prefix(argv[i], "-n"))
{
num_term = atoi(&argv[i][2]);
if (num_term > MAX_TERM_DATA) num_term = MAX_TERM_DATA;
else if (num_term < 1) num_term = 1;
continue;
}
plog_fmt("Ignoring option: %s", argv[i]);
}
/* Attempt to open the local display */
dpy = XOpenDisplay(dpy_name);
/* Failure -- assume no X11 available */
if (!dpy) return (-1);
/* Close the local display */
XCloseDisplay(dpy);
#ifdef USE_XAW_LANG
/* Support locale processing */
XtSetLanguageProc(NULL, NULL, NULL);
#endif /* USE_XAW_LANG */
/* Initialize the toolkit */
topLevel = XtAppInitialize(&appcon, "Angband", NULL, 0, &argc, argv,
fallback, NULL, 0);
/* Initialize the windows */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
term_data_init(td, topLevel, 1024, termNames[i],
(i == 0) ? specialArgs : defaultArgs,
TERM_FALLBACKS, i);
angband_term[i] = Term;
}
/* Activate the "Angband" window screen */
Term_activate(&data[0].t);
/* Raise the "Angband" window */
term_raise(&data[0]);
#ifdef USE_GRAPHICS
/* Try graphics */
switch (arg_graphics)
{
case GRAPHICS_ADAM_BOLT:
/* Use tile graphics of Adam Bolt */
bitmap_file = "16x16.bmp";
/* Try the "16x16.bmp" file */
path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA, format("graf/%s", bitmap_file));
/* Use the "16x16.bmp" file if it exists */
if (0 == fd_close(fd_open(filename, O_RDONLY)))
{
/* Use graphics */
use_graphics = GRAPHICS_ADAM_BOLT;
use_transparency = TRUE;
pict_wid = pict_hgt = 16;
ANGBAND_GRAF = "new";
break;
}
/* Fall through */
case GRAPHICS_ORIGINAL:
/* Use original tile graphics */
bitmap_file = "8x8.bmp";
/* Try the "8x8.bmp" file */
path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA, format("graf/%s", bitmap_file));
/* Use the "8x8.bmp" file if it exists */
if (0 == fd_close(fd_open(filename, O_RDONLY)))
{
/* Use graphics */
use_graphics = GRAPHICS_ORIGINAL;
pict_wid = pict_hgt = 8;
ANGBAND_GRAF = "old";
break;
}
break;
case GRAPHICS_DAVID_GERVAIS:
/* Use tile graphics of David Gervais */
bitmap_file = "32x32.bmp";
/* Use graphics */
use_graphics = GRAPHICS_DAVID_GERVAIS;
use_transparency = TRUE;
pict_wid = pict_hgt = 32;
ANGBAND_GRAF = "david";
break;
}
/* Load graphics */
if (use_graphics)
{
/* Hack -- Get the Display */
term_data *td = &data[0];
Widget widget = (Widget)(td->widget);
Display *dpy = XtDisplay(widget);
XImage *tiles_raw;
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
td->widget->angband.tiles = NULL;
}
path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA, format("graf/%s", bitmap_file));
/* Load the graphical tiles */
tiles_raw = ReadBMP(dpy, filename);
if (tiles_raw)
{
/* Initialize the windows */
for (i = 0; i < num_term; i++)
{
int j;
bool same = FALSE;
term_data *td = &data[i];
term_data *o_td = NULL;
term *t = &td->t;
t->pict_hook = Term_pict_xaw;
t->higher_pict = TRUE;
/* Look for another term with same font size */
for (j = 0; j < i; j++)
{
o_td = &data[j];
if ((td->widget->angband.tilewidth == o_td->widget->angband.tilewidth) &&
(td->widget->angband.fontheight == o_td->widget->angband.fontheight))
{
same = TRUE;
break;
}
}
if (!same)
{
/* Resize tiles */
td->widget->angband.tiles = ResizeImage(dpy, tiles_raw,
pict_wid, pict_hgt,
td->widget->angband.tilewidth,
td->widget->angband.fontheight);
}
else
{
/* Use same graphics */
td->widget->angband.tiles = o_td->widget->angband.tiles;
}
}
/* Free tiles_raw */
FREE(tiles_raw);
}
/* Initialize the transparency temp storage */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
int ii, jj;
int depth = DefaultDepth(dpy, DefaultScreen(dpy));
Visual *visual = DefaultVisual(dpy, DefaultScreen(dpy));
int total;
/* Determine total bytes needed for image */
ii = 1;
jj = (depth - 1) >> 2;
while (jj >>= 1) ii <<= 1;
total = td->widget->angband.tilewidth *
td->widget->angband.fontheight * ii;
TmpData = (char *)malloc(total);
td->widget->angband.TmpImage = XCreateImage(dpy,
visual,depth,
ZPixmap, 0, TmpData,
td->widget->angband.tilewidth,
td->widget->angband.fontheight, 8, 0);
}
}
#endif /* USE_GRAPHICS */
/* Success */
return (0);
}
/*
* Initialization function for an "X11" module to Angband
*/
errr init_x11(int argc, char **argv)
{
int i;
cptr dpy_name = "";
int num_term = 1;
#ifdef USE_GRAPHICS
cptr bitmap_file = "";
char filename[1024];
int pict_wid = 0;
int pict_hgt = 0;
char *TmpData;
#endif /* USE_GRAPHICS */
/* Parse args */
for (i = 1; i < argc; i++)
{
if (prefix(argv[i], "-d"))
{
dpy_name = &argv[i][2];
continue;
}
#ifdef USE_GRAPHICS
if (prefix(argv[i], "-s"))
{
smoothRescaling = FALSE;
continue;
}
if (prefix(argv[i], "-o"))
{
arg_graphics = GRAPHICS_ORIGINAL;
continue;
}
if (prefix(argv[i], "-a"))
{
arg_graphics = GRAPHICS_ADAM_BOLT;
continue;
}
if (prefix(argv[i], "-g"))
{
smoothRescaling = FALSE;
arg_graphics = GRAPHICS_DAVID_GERVAIS;
continue;
}
if (prefix(argv[i], "-b"))
{
use_bigtile = TRUE;
continue;
}
#endif /* USE_GRAPHICS */
if (prefix(argv[i], "-n"))
{
num_term = atoi(&argv[i][2]);
if (num_term > MAX_TERM_DATA) num_term = MAX_TERM_DATA;
else if (num_term < 1) num_term = 1;
continue;
}
plog_fmt("Ignoring option: %s", argv[i]);
}
/* Init the Metadpy if possible */
if (Metadpy_init_name(dpy_name)) return (-1);
/* Prepare cursor color */
MAKE(xor, infoclr);
Infoclr_set(xor);
Infoclr_init_ppn(Metadpy->fg, Metadpy->bg, "xor", 0);
/* Prepare normal colors */
for (i = 0; i < 256; ++i)
{
Pixell pixel;
MAKE(clr[i], infoclr);
Infoclr_set(clr[i]);
/* Acquire Angband colors */
color_table[i][0] = angband_color_table[i][0];
color_table[i][1] = angband_color_table[i][1];
color_table[i][2] = angband_color_table[i][2];
color_table[i][3] = angband_color_table[i][3];
/* Default to monochrome */
pixel = ((i == 0) ? Metadpy->bg : Metadpy->fg);
/* Handle color */
if (Metadpy->color)
{
/* Create pixel */
pixel = create_pixel(Metadpy->dpy,
color_table[i][1],
color_table[i][2],
color_table[i][3]);
}
/* Initialize the color */
Infoclr_init_ppn(pixel, Metadpy->bg, "cpy", 0);
}
/* Initialize the windows */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
/* Initialize the term_data */
term_data_init(td, i);
/* Save global entry */
angband_term[i] = Term;
}
/* Raise the "Angband" window */
Infowin_set(data[0].win);
Infowin_raise();
/* Activate the "Angband" window screen */
Term_activate(&data[0].t);
#ifdef USE_GRAPHICS
/* Try graphics */
switch (arg_graphics)
{
case GRAPHICS_ADAM_BOLT:
/* Use tile graphics of Adam Bolt */
bitmap_file = "16x16.bmp";
/* Try the "16x16.bmp" file */
path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA, format("graf/%s", bitmap_file));
/* Use the "16x16.bmp" file if it exists */
if (0 == fd_close(fd_open(filename, O_RDONLY)))
{
/* Use graphics */
use_graphics = TRUE;
use_transparency = TRUE;
pict_wid = pict_hgt = 16;
ANGBAND_GRAF = "new";
break;
}
/* Fall through */
case GRAPHICS_ORIGINAL:
/* Use original tile graphics */
bitmap_file = "8x8.bmp";
/* Try the "8x8.bmp" file */
path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA, format("graf/%s", bitmap_file));
/* Use the "8x8.bmp" file if it exists */
if (0 == fd_close(fd_open(filename, O_RDONLY)))
{
/* Use graphics */
use_graphics = TRUE;
pict_wid = pict_hgt = 8;
ANGBAND_GRAF = "old";
break;
}
break;
case GRAPHICS_DAVID_GERVAIS:
/* Use tile graphics of David Gervais */
bitmap_file = "32x32.bmp";
/* Use graphics */
use_graphics = TRUE;
use_transparency = TRUE;
pict_wid = pict_hgt = 32;
ANGBAND_GRAF = "david";
break;
}
/* Load graphics */
if (use_graphics)
{
Display *dpy = Metadpy->dpy;
XImage *tiles_raw;
/* Initialize */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
td->tiles = NULL;
}
path_build(filename, sizeof(filename), ANGBAND_DIR_XTRA, format("graf/%s", bitmap_file));
/* Load the graphical tiles */
tiles_raw = ReadBMP(dpy, filename);
if (tiles_raw)
{
/* Initialize the windows */
for (i = 0; i < num_term; i++)
{
int j;
bool same = FALSE;
term_data *td = &data[i];
term_data *o_td = NULL;
term *t = &td->t;
/* Graphics hook */
t->pict_hook = Term_pict_x11;
/* Use graphics sometimes */
t->higher_pict = TRUE;
/* Look for another term with same font size */
for (j = 0; j < i; j++)
{
o_td = &data[j];
if ((td->fnt->twid == o_td->fnt->twid) && (td->fnt->hgt == o_td->fnt->hgt))
{
same = TRUE;
break;
}
}
if (!same)
{
/* Resize tiles */
td->tiles = ResizeImage(dpy, tiles_raw,
pict_wid, pict_hgt,
td->fnt->twid, td->fnt->hgt);
}
else
{
/* Use same graphics */
td->tiles = o_td->tiles;
}
}
/* Free tiles_raw */
FREE(tiles_raw);
}
/* Initialize the transparency masks */
for (i = 0; i < num_term; i++)
{
term_data *td = &data[i];
int ii, jj;
int depth = DefaultDepth(dpy, DefaultScreen(dpy));
Visual *visual = DefaultVisual(dpy, DefaultScreen(dpy));
int total;
/* Determine total bytes needed for image */
ii = 1;
jj = (depth - 1) >> 2;
while (jj >>= 1) ii <<= 1;
total = td->fnt->twid * td->fnt->hgt * ii;
TmpData = (char *)malloc(total);
td->TmpImage = XCreateImage(dpy,visual,depth,
ZPixmap, 0, TmpData,
td->fnt->twid, td->fnt->hgt, 32, 0);
}
}
#endif /* USE_GRAPHICS */
/* Success */
return (0);
}
Image* generate_rendition(Image *const image, ImageInfo const*image_info, char const* spec, char const* rendition_path, ExceptionInfo *exception) {
unsigned long crop_x;
unsigned long crop_y;
unsigned long crop_width;
unsigned long crop_height;
unsigned long width;
unsigned long height;
unsigned int quality;
unsigned int resize;
double blur;
unsigned int is_progressive;
Image const* cropped;
Image *resized;
RectangleInfo geometry;
FilterTypes filter;
ImageInfo *rendition_info;
if (sscanf(spec, "%lux%lu+%lu+%lu+%lux%lu+%u+%lf+%u+%u", &crop_width, &crop_height, &crop_x, &crop_y, &width, &height, &resize, &blur, &quality, &is_progressive)) {
if (width > 0 && height > 0) {
if (crop_width > 0 && crop_height > 0) {
geometry.x = crop_x;
geometry.y = crop_y;
geometry.width = crop_width;
geometry.height = crop_height;
cropped = CropImage(image, &geometry, exception);
if (!cropped) {
CatchException(exception);
return NULL;
}
} else {
cropped = image;
}
filter = get_filter(resize);
switch (resize) {
case Sample:
resized = SampleImage(cropped, width, height, exception);
break;
case Scale:
resized = ScaleImage(cropped, width, height, exception);
break;
case Thumbnail:
resized = ThumbnailImage(cropped, width, height, exception);
break;
case Point:
case Box:
case Triangle:
case Hermite:
case Hanning:
case Hamming:
case Blackman:
case Gaussian:
case Quadratic:
case Cubic:
case Catrom:
case Mitchell:
case Lanczos:
case Bessel:
case Sinc:
resized = ResizeImage(cropped, width, height, filter, blur, exception);
break;
}
if (!resized) {
CatchException(exception);
return NULL;
}
rendition_info = CloneImageInfo(image_info);
rendition_info->quality = quality;
strncpy(resized->filename, rendition_path, MaxTextExtent);
if (is_progressive) {
rendition_info->interlace = LineInterlace;
printf("progressive: %s\n", rendition_path);
}
if (!WriteImage(rendition_info, resized)) {
CatchException(exception);
DestroyImageInfo(rendition_info);
return NULL;
}
printf("wrote %s\n", resized->filename);
DestroyImageInfo(rendition_info);
return resized;
}
}
return NULL;
}
