// Frame image
Magick::frameImage::frameImage( const Magick::Geometry &geometry_ )
: _width( geometry_.width() ),
_height( geometry_.height() ),
_outerBevel( geometry_.xOff() ),
_innerBevel( geometry_.yOff() )
{
}
Magick::Geometry scale (const Magick::Geometry& geometry) const
{
return Magick::Geometry (x_scale_ * geometry.width (),
y_scale_ * geometry.height (),
x_scale_ * geometry.xOff (),
y_scale_ * geometry.yOff ());
}
Magick::floodFillColorImage::floodFillColorImage( const Magick::Geometry &point_,
const Magick::Color &fillColor_ )
: _x(point_.xOff()),
_y(point_.yOff()),
_fillColor(fillColor_),
_borderColor()
{
}
Magick::floodFillTextureImage::floodFillTextureImage( const Magick::Geometry &point_,
const Magick::Image &texture_ )
: _x(point_.xOff()),
_y(point_.yOff()),
_texture(texture_),
_borderColor()
{
}
Magick::compositeImage::compositeImage( const Magick::Image &compositeImage_,
const Magick::Geometry &offset_,
Magick::CompositeOperator compose_ )
: _compositeImage( compositeImage_ ),
_xOffset ( offset_.xOff() ),
_yOffset ( offset_.yOff() ),
_compose ( compose_ )
{
}
int Magick::operator < ( const Magick::Geometry& left_,
const Magick::Geometry& right_ )
{
return (
( left_.width() * left_.height() )
<
( right_.width() * right_.height() )
);
}
Magick::floodFillTextureImage::floodFillTextureImage(
const Magick::Geometry &point_,const Magick::Image &texture_,
const Magick::Color &borderColor_,const bool invert_)
: _x(point_.xOff()),
_y(point_.yOff()),
_texture(texture_),
_borderColor(borderColor_),
_invert(invert_)
{
}
//==============================================================================================
const Magick::Geometry* MagickGeometry::CreateGeometry()
{
Magick::Geometry* result = new Magick::Geometry(Width, Height, Math::Abs(X), Math::Abs(Y), X < 0, Y < 0);
result->percent(IsPercentage);
result->aspect(IgnoreAspectRatio);
result->less(Less);
result->greater(Greater);
return result;
}
void KBuild::Symbol::Frame::getGeometry(Magick::Geometry& geo) const {
using namespace Magick;
const Image atlas = parent->parent->atlases[getAtlasIdx()].second;
float_type w0 = atlas.columns();
float_type h0 = atlas.rows();
geo.xOff(size_t( floor(w0*atlas_bbox.x()) ));
geo.yOff(size_t( floor(h0*atlas_bbox.y()) ));
geo.width(size_t( floor(w0*atlas_bbox.w() + 0.5) ));
geo.height(size_t( floor(h0*atlas_bbox.h() + 0.5) ));
}
void copyImage(Magick::Image& src,
yarp::sig::ImageOf<yarp::sig::PixelRgb>& dest) {
Magick::Geometry g = src.size();
int h = g.height();
int w = g.width();
src.depth(8);
dest.resize(w,h);
for (int i=0; i<h; i++) {
// must transfer row by row, since YARP may use padding in representation
Magick::PixelPacket *packet = src.getPixels(0,i,w,1);
src.writePixels(Magick::RGBQuantum,(unsigned char *)(&dest.pixel(0,i)));
}
src.syncPixels();
}
void Magick::Options::page ( const Magick::Geometry &pageSize_ )
{
if ( !pageSize_.isValid() )
_imageInfo->page=(char *) RelinquishMagickMemory(_imageInfo->page);
else
Magick::CloneString( &_imageInfo->page, pageSize_ );
}
void Magick::Options::density ( const Magick::Geometry &density_ )
{
if ( !density_.isValid() )
_imageInfo->density=(char *) RelinquishMagickMemory(_imageInfo->density);
else
Magick::CloneString( &_imageInfo->density, density_ );
}
ResizeTest(std::string fileName) {
source.loadFile(fileName);
for (int i=1; i<99; ++i) {
Magick::Image image = source.getImage();
image.magick("JPEG");
image.quality(50);
Magick::Geometry resizeGeometry;
resizeGeometry.percent(true);
resizeGeometry.width(i);
resizeGeometry.height(i);
image.resize(resizeGeometry);
Magick::Blob blob;
image.write(&blob);
imghash::Source target((char*)blob.data(), blob.length());
images.push_back(target);
}
}
bool convert::resize( long numOfPix, const string &fIN, const string &fOUT ) {
string outf;
if ( fOUT == "" ) outf = fIN;
else outf = fOUT;
#ifdef HAVE_MAGICK
Magick::Image img;
try {
img.ping( fIN );
Magick::Geometry sz = img.size();
uint w = sz.width(), h = sz.height();
if ( w*h <= numOfPix ) return true;
double factor = sqrt((double)numOfPix/(double)(w*h));
stringstream ss;
ss << floor(w*factor) << "x" << floor(h*factor) << ">";
img.read( fIN );
img.scale( ss.str() );
img.write( outf );
return true;
} catch ( Magick::Exception &ex ) {
cerr << " Exception while reading/resizing image: " << ex.what() << endl;
return false;
}
#else // ! HAVE_MAGICK++
string cmd("-resize");
stringstream ss;
ss << numOfPix << "@> ";
int pid = fork();
int status;
switch( pid ) {
case 0:
execl( pathToConvert.c_str(), fIN.c_str(), cmd.c_str(), ss.str().c_str(), outf.c_str(), (char *) NULL );
return false;
break;
default:
waitpid( pid, &status, 0 );
return WIFEXITED( status );
}
#endif // HAVE_MAGICK
}
MagickPPExport int Magick::operator == (const Magick::Geometry& left_,
const Magick::Geometry& right_)
{
return((left_.aspect() == right_.aspect()) &&
(left_.fillArea() == right_.fillArea()) &&
(left_.greater() == right_.greater()) &&
(left_.height() == right_.height()) &&
(left_.isValid() == right_.isValid()) &&
(left_.less() == right_.less()) &&
(left_.limitPixels() == right_.limitPixels()) &&
(left_.percent() == right_.percent()) &&
(left_.width() == right_.width()) &&
(left_.xNegative() == right_.xNegative()) &&
(left_.xOff() == right_.xOff()) &&
(left_.yNegative() == right_.yNegative()) &&
(left_.yOff() == right_.yOff()));
}
void TimeLapseCapture::imageCaptured(QString format, Magick::Blob blob, Magick::Geometry sizeHint) {
bool readRawFromFile = false;
QString framePath = output.path() + QDir::separator()
+ leadingZeros(capturedCnt, FRAME_FILE_LEADING_ZEROS) + "_" + leadingZeros(capturedSubsequence, 2);
if (format == "RGB") {
if (storeRawImages) {
// store RAW RGB data in PPM format
QString pgmHeader = QString("P6\n%1 %2\n255\n").arg(sizeHint.width()).arg(sizeHint.height());
std::string headerStr = pgmHeader.toStdString();
const char *headerBytes = headerStr.c_str();
size_t headerLen = strlen(headerBytes);
if (shutterSpdAlg != NULL && capturedSubsequence == 0) {
Magick::Image capturedImage;
capturedImage.read(blob, sizeHint, 8, "RGB");
shutterSpdAlg->update(capturedImage);
}
framePath += ".ppm";
QFile file(framePath);
file.open(QIODevice::WriteOnly);
file.write(headerBytes, headerLen);
file.write((char*) blob.data(), blob.length());
file.close();
} else {
// convert RGB data to JPEG
Magick::Image capturedImage;
capturedImage.read(blob, sizeHint, 8, "RGB");
if (shutterSpdAlg != NULL && capturedSubsequence == 0) {
shutterSpdAlg->update(capturedImage);
}
QDateTime now = QDateTime::currentDateTime();
QString exifDateTime = now.toString("yyyy:MM:dd HH:mm:ss");\
// ImageMagick don't support writing of exif data
// TODO: setup exif timestamp correctly
capturedImage.attribute("EXIF:DateTime", exifDateTime.toStdString());
//capturedImage.defineValue("EXIF", "DateTime", exifDateTime.toStdString());
capturedImage.compressType(Magick::JPEGCompression);
capturedImage.magick("JPEG");
framePath += ".jpeg";
capturedImage.write(framePath.toStdString());
}
} else {
if (shutterSpdAlg != NULL && capturedSubsequence == 0) {
try {
Magick::Image capturedImage;
capturedImage.read(blob, format.toStdString());
shutterSpdAlg->update(capturedImage);
} catch (const std::exception &e) {
err << "Failed to decode captured image (" << format << "): " << QString::fromUtf8(e.what()) << endl;
readRawFromFile = true;
}
}
// store other formats in device specific format
framePath += "." + format;
QFile file(framePath);
file.open(QIODevice::WriteOnly);
file.write((char*) blob.data(), blob.length());
file.close();
if (readRawFromFile && shutterSpdAlg != NULL && capturedSubsequence == 0) {
/* I don't understand ImageMagick correctly, but it fails with reading RAW files
* from memory blob, but reading from file works (sometimes).
* Maybe, it don't support delegating (dcraw, ufraw...) with memory data...
*/
try {
Magick::Image capturedImage;
capturedImage.read(framePath.toStdString());
shutterSpdAlg->update(capturedImage);
} catch (const std::exception &e) {
err << "Failed to decode captured image (" << framePath << "): " << QString::fromUtf8(e.what()) << endl;
}
}
}
verboseOutput << "Captured frame saved to " << framePath << endl;
capturedSubsequence++;
}
Initialize(x, y, (int)percentageWidth, (int)percentageHeight, true);
}
//==============================================================================================
MagickGeometry::MagickGeometry(Rectangle rectangle)
{
Initialize(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, false);
}
//==============================================================================================
MagickGeometry::MagickGeometry(String^ value)
{
Throw::IfNullOrEmpty("value", value);
std::string geometrySpec;
Marshaller::Marshal(value, geometrySpec);
Magick::Geometry geometry = Magick::Geometry(geometrySpec);
Throw::IfFalse("geometry", geometry.isValid(), "Invalid geometry specified.");
Initialize(geometry);
}
//==============================================================================================
bool MagickGeometry::operator == (MagickGeometry^ left, MagickGeometry^ right)
{
return Object::Equals(left, right);
}
//==============================================================================================
bool MagickGeometry::operator != (MagickGeometry^ left, MagickGeometry^ right)
{
return !Object::Equals(left, right);
}
//==============================================================================================
DefinitionFile * ResourcePackerScreen::ProcessPSD(const String & processDirectoryPath, const String & psdPathname, const String & psdName)
{
int32 maxTextureSize = 1024;
if (CommandLineParser::Instance()->IsFlagSet("--tsize2048"))
{
maxTextureSize = 2048;
}
// TODO: Check CRC32
std::vector<Magick::Image> layers;
String psdNameWithoutExtension = FileSystem::ReplaceExtension(psdName, "");
try
{
Magick::readImages(&layers, psdPathname);
if (layers.size() == 0)
{
Logger::Error("Number of layers is too low: %s", psdPathname.c_str());
return 0;
}
if (layers.size() == 1)
{
layers.push_back(layers[0]);
}
//Logger::Debug("psd file: %s wext: %s", psdPathname.c_str(), psdNameWithoutExtension.c_str());
int width = (int)layers[0].columns();
int height = (int)layers[0].rows();
for(int k = 1; k < (int)layers.size(); ++k)
{
Magick::Image & currentLayer = layers[k];
/*
MagickCore::ResetImagePropertyIterator(currentLayer.image());
const char * property = MagickCore::GetNextImageProperty(currentLayer.image());
if (property != (const char *) NULL)
{
printf(" Properties:\n");
while (property != (const char *) NULL)
{
printf(" %c",*property);
if (strlen(property) > 1)
printf("%s: ",property+1);
if (strlen(property) > 80)
printf("\n");
const char * value = MagickCore::GetImageProperty(currentLayer.image(), property);
if (value != (const char *) NULL)
printf("%s\n",value);
property = MagickCore::GetNextImageProperty(currentLayer.image());
}
} */
currentLayer.crop(Magick::Geometry(width,height, 0, 0));
currentLayer.magick("PNG");
String outputFile = processDirectoryPath + String("/") + psdNameWithoutExtension;
outputFile += String(Format("%d.png", k - 1));
currentLayer.write(outputFile);
}
DefinitionFile * defFile = new DefinitionFile;
defFile->filename = processDirectoryPath + String("/") + psdNameWithoutExtension + String(".txt");
// Logger::Debug("filename: %s", defFile->filename.c_str());
defFile->spriteWidth = width;
defFile->spriteHeight = height;
defFile->frameCount = (int)layers.size() -1;
defFile->frameRects = new Rect2i[defFile->frameCount];
for(int k = 1; k < (int)layers.size(); ++k)
{
Magick::Image & currentLayer = layers[k];
Magick::Geometry bbox = currentLayer.page();
int xOff = (int)bbox.xOff();
if (bbox.xNegative())
xOff = -xOff;
int yOff = (int)bbox.yOff();
if (bbox.yNegative())
yOff = -yOff;
defFile->frameRects[k - 1] = Rect2i(xOff, yOff, (int32)bbox.width(), (int32)bbox.height());
//printf("Percent: %d Aspect: %d Greater: %d Less: %d\n", (int)bbox.percent(), (int)bbox.aspect(), (int)bbox.greater(), (int)bbox.less());
if ((defFile->frameRects[k - 1].dx >= maxTextureSize) || (defFile->frameRects[k - 1].dy >= maxTextureSize))
{
printf("* WARNING * - frame of %s layer %d is bigger than maxTextureSize(%d) layer exportSize (%d x %d) FORCE REDUCE TO (%d x %d). Bewarned!!! Results not guaranteed!!!\n", psdName.c_str(), k - 1, maxTextureSize
, defFile->frameRects[k - 1].dx, defFile->frameRects[k - 1].dy, width, height);
defFile->frameRects[k - 1].dx = width;
defFile->frameRects[k - 1].dy = height;
}
if (CommandLineParser::Instance()->IsFlagSet("--add0pixel"))
{
}else if (CommandLineParser::Instance()->IsFlagSet("--add1pixel"))
{
defFile->frameRects[k - 1].dx++;
defFile->frameRects[k - 1].dy++;
}
else if (CommandLineParser::Instance()->IsFlagSet("--add2pixel"))
{
defFile->frameRects[k - 1].dx+=2;
defFile->frameRects[k - 1].dy+=2;
}
else if (CommandLineParser::Instance()->IsFlagSet("--add4pixel"))
{
defFile->frameRects[k - 1].dx+=4;
defFile->frameRects[k - 1].dy+=4;
}
else if(CommandLineParser::Instance()->IsFlagSet("--add2sidepixel"))
{
defFile->frameRects[k - 1].dx+=2;
defFile->frameRects[k - 1].dy+=2;
}
else
{
defFile->frameRects[k - 1].dx++;
defFile->frameRects[k - 1].dy++;
}
}
return defFile;
}
catch( Magick::Exception &error_ )
{
std::cout << "Caught exception: " << error_.what() << " file: "<< psdPathname << std::endl;
return 0;
}
return 0;
}
// Roll image (rolls image vertically and horizontally) by specified
// number of columnms and rows)
Magick::rollImage::rollImage( const Magick::Geometry &roll_ )
: _columns( roll_.width() ),
_rows( roll_.height() )
{
}
