void MagickImageLoader::convertImageDpi(Magick::Image& image) {
if (image.magick() == "PDF" | image.magick() == "SVG" || image.magick() == "DJVU") {
//change from default 72 dpi
image.resolutionUnits(Magick::PixelsPerInchResolution);
image.density(Magick::Geometry(MIN_DPI_FOR_VECTOR_FORMAT, MIN_DPI_FOR_VECTOR_FORMAT));
}
}
void PipelineStabDetect::onInput(InputImageInfo info, Magick::Image image) {
try {
if (!initialized) {
init(image);
}
if (image.rows() != height || image.columns() != width) {
throw runtime_error(QString("Not uniform image size! %").arg(info.file.fileName()).toStdString());
}
Magick::Blob blob;
// set raw RGBS output format & convert it into a Blob
if (image.depth() > 8)
*err << "Warning: we lost some information by converting to 8bit depth (now " << image.depth() << ")" << endl;
image.depth(8);
image.magick("RGB");
image.write(&blob);
LocalMotions localmotions;
VSFrame frame;
size_t dataLen = blob.length();
Q_ASSERT(fi.planes == 1);
Q_ASSERT(dataLen == image.baseColumns() * image.baseRows() * 3);
if (stabConf->mdConf.show > 0) { // create copy of blob
frame.data[0] = new uint8_t[dataLen];
memcpy(frame.data[0], blob.data(), dataLen);
} else {
frame.data[0] = (uint8_t*) blob.data();
}
frame.linesize[0] = image.baseColumns() * 3;
if (vsMotionDetection(&md, &localmotions, &frame) != VS_OK) {
throw runtime_error("motion detection failed");
} else {
if (vsWriteToFile(&md, f, &localmotions) != VS_OK) {
throw runtime_error("cannot write to transform file");
}
vs_vector_del(&localmotions);
}
if (stabConf->mdConf.show > 0) {
// if we want to store transformations, we have to create new image...
Magick::Geometry g(width, height);
Magick::Blob oblob(frame.data[0], dataLen);
Magick::Image oimage;
oimage.read(oblob, g, 8, "RGB");
delete[] frame.data[0];
emit input(info, oimage);
} else {
emit input(info, image);
}
} catch (exception &e) {
emit error(e.what());
}
}
void MagickImageLoader::convertImageToDib(Magick::Image& image, Magick::Blob& blob) {
image.magick("DIB");
if(image.xResolution() == 0 || image.yResolution() == 0) {
image.resolutionUnits(Magick::PixelsPerInchResolution);
image.density(Magick::Geometry(75, 75));
}
image.write(&blob);
}
void MagickImageExporter::saveToStream(const ImageRawData& image, std::ostream& os) {
if (image.isNull())
throw Exception("[MagickImageExporter::save] null image given");
if (os.fail())
throw Exception("[MagickImageExporter::save] invalid stream");
Magick::Blob blob(image.data(), image.dataSize());
try {
Magick::Image image;
image.verbose(true);
image.magick("DIB");
image.read(blob);
image.magick(formatToString(format()));
image.write(&blob);
os.write((char*) blob.data(), blob.length());
} catch (Magick::Exception &e) {
std::cerr << e.what() << "\n";
throw Exception("MagickImageExporter::load failed");
}
}
ItemSequence_t
ConvertSVGFunction::evaluate(
const ExternalFunction::Arguments_t& aArgs,
const StaticContext* aSctxCtx,
const DynamicContext* aDynCtx) const
{
Magick::Image lImage;
String lSVG = ImageFunction::getOneStringArg(aArgs, 0);
ImageFunction::getImageFromString(aDynCtx, lSVG, lImage, false);
if (lImage.magick().compare("SVG") != 0) {
ImageFunction::throwErrorWithQName(aDynCtx, "IM002", "The passed xs:base64Binary is not an image of type SVG");
}
String lType = ImageFunction::getOneStringArg(aArgs, 1);
lImage.magick(lType.c_str());
String lEncodedContent = ImageFunction::getEncodedStringFromImage(aDynCtx, lImage);
Item lItem( theModule->getItemFactory()->createBase64Binary(lEncodedContent.c_str(), lEncodedContent.size(), true));
ImageFunction::checkIfItemIsNull(lItem);
return ItemSequence_t(new SingletonItemSequence(lItem));
}
void WriteFrame::onInput(InputImageInfo info, Magick::Image img) {
QString framePath = outputDir.path() + QDir::separator()
+ leadingZeros(info.frame, FRAME_FILE_LEADING_ZEROS) + QString(".jpeg");
*verboseOutput << "Write frame " << framePath << endl;
if (!dryRun) {
img.compressType(Magick::JPEGCompression);
img.magick( "JPEG" );
img.write(framePath.toStdString());
}
// update image location & emit signal
info.file = QFileInfo(framePath);
emit input(info, img);
}
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);
}
}
ItemSequence_t
ConvertFunction::evaluate(
const ExternalFunction::Arguments_t& aArgs,
const StaticContext* aSctxCtx,
const DynamicContext* aDynCtx) const
{
Magick::Image lImage;
ImageFunction::getOneImageArg(aDynCtx, aArgs, 0 , lImage);
String lType;
lType = ImageFunction::getOneStringArg(aArgs, 1);
lImage.magick(lType.c_str()); // Set output format
String lEncodedContent = ImageFunction::getEncodedStringFromImage(aDynCtx, lImage);
Item lItem( theModule->getItemFactory()->createBase64Binary(lEncodedContent.c_str(), lEncodedContent.size(), true) );
ImageFunction::checkIfItemIsNull(lItem);
return ItemSequence_t(new SingletonItemSequence(lItem));
}
QImage ImageItem::previewRotate(short degrees)
{
Magick::Image image;
if (m_tempImage) {
m_tempImage->open();
image.read(m_tempImage->fileName().toStdString());
image.magick("jpg");
} else {
image.read(absoluteFilePath().toStdString());
m_tempImage = new QTemporaryFile(qApp);
m_tempImage->open();
}
image.rotate(degrees);
Magick::Blob buffer;
image.write(&buffer);
QImage output;
output.loadFromData((const uchar*) buffer.data(), buffer.length());
output.save(m_tempImage, "JPEG");
m_tempImage->close();
return output;
}
Magick::Blob ImgMgk::conv(const void *data, size_t length, const std::string &text)
{
Magick::Blob blob1;
Magick::Blob blob(data,length);
try
{
Magick::Image image;
image.read(blob);
image.annotate(text, Magick::SouthEastGravity);
image.magick("JPEG"); // Set JPEG output format
image.write(&blob1);
}
catch( std::exception &error_ )
{
Log::err("Caught exception: %s", error_.what());
return blob;
}
return blob1;
}
void DrvSDL::WriteGif() {
std::list<Magick::Image> gif;
int num = 0;
for(std::list<Magick::Blob>::iterator it = image_.begin(); it != image_.end(); it++) {
Magick::Image image;
image.magick("RGB");
image.depth(32);
image.size(Magick::Geometry(cols_ * pixels.x, rows_ * pixels.y));
Magick::PixelPacket *pixel_cache = image.getPixels(0, 0, cols_ * pixels.x, rows_ * pixels.y);
for(int n = 0; n < rows_ * pixels.y * cols_ * pixels.x; n++) {
int col = ((int *)(*it).data())[n];
uint8_t *rgb = (uint8_t *) &col;
Magick::PixelPacket *gif_pixel = pixel_cache + n;
*gif_pixel = Magick::ColorRGB(rgb[0] / 256.0, rgb[1] / 256.0, rgb[2] / 256.0);
}
image.syncPixels();
gif.push_back(image);
LCDInfo("Image %d", num++);
}
LCDInfo("Writing GIF image...");
for_each(gif.begin(), gif.end(), Magick::animationDelayImage(ani_speed_ / 10));
Magick::writeImages(gif.begin(), gif.end(), gif_file_);
}
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++;
}
void Magick::magickImage::operator()( Magick::Image &image_ ) const
{
image_.magick( _magick );
}
//
// Output filter.
//
static apr_status_t resize_output_filter(ap_filter_t* f, apr_bucket_brigade* in_bb)
{
request_rec* rec =f->r;
resize_conf* conf = (resize_conf*)ap_get_module_config(rec->per_dir_config, &resizeimage_module);
const char* content_type, *target_type = "JPEG";
const char* image_url, *resize_param, *image_hash=NULL;
Magick::Blob blob;
char* vlob = NULL;
size_t vlob_length = 0;
int cache_hit = FALSE;
AP_LOG_VERBOSE(rec, "Incoming %s.", __FUNCTION__);
// Pass thru by request types.
if(rec->status!=HTTP_OK || rec->main!=NULL || rec->header_only
|| (rec->handler!= NULL && strcmp(rec->handler, "default-handler") == 0)) goto PASS_THRU;
AP_LOG_VERBOSE(rec, "-- Checking responce headers.");
// Obtain and erase x-resize-image header or pass through.
image_url = get_and_unset_header(rec->headers_out, X_RESIZE);
if(image_url== NULL || image_url[0]=='\0') {
image_url = get_and_unset_header(rec->err_headers_out, X_RESIZE);
}
if(image_url==NULL || image_url[0]=='\0') goto PASS_THRU;
// Check content-type
content_type = rec->content_type;
if(content_type) {
if(strcasecmp(content_type, "image/jpeg")==0) {
target_type = "JPEG";
} else
if(strcasecmp(content_type, "image/png")==0) {
target_type = "PNG";
} else
if(strcasecmp(content_type, "image/gif")==0) {
target_type = "GIF";
} else goto PASS_THRU;
}
// Resize parameter
resize_param = get_and_unset_header(rec->headers_out, X_RESIZE_PARAM);
if(resize_param==NULL || resize_param[0]=='\0') {
resize_param = get_and_unset_header(rec->err_headers_out, X_RESIZE_PARAM);
}
if(resize_param[0]=='\0') resize_param = NULL;
// Image hash
image_hash = get_and_unset_header(rec->headers_out, X_RESIZE_HASH);
if(image_hash==NULL || image_hash[0]=='\0') {
image_hash = get_and_unset_header(rec->err_headers_out, X_RESIZE_HASH);
}
// Open image and resize.
AP_LOG_INFO(rec, "URL: %s, %s => %s (%s)", image_url, content_type, resize_param, image_hash);
if(image_hash) {
// Try memcached...
image_hash = apr_psprintf(rec->pool, "%s:%s:%s", image_hash, target_type, resize_param);
memcached_return r;
uint32_t flags;
vlob = memcached_get(conf->memc, image_hash, strlen(image_hash), &vlob_length, &flags, &r);
if(r==MEMCACHED_SUCCESS) {
AP_LOG_DEBUG(rec, "Restored from memcached: %s, len=%d", image_hash, vlob_length);
cache_hit = TRUE;
goto WRITE_DATA;
} else {
AP_LOG_DEBUG(rec, "Can't restore from memcached: %s - %s(%d)", image_hash, memcached_strerror(conf->memc, r), r);
}
}
// Reszize
try {
Magick::Image image;
image.read(image_url);
if(resize_param) image.zoom(resize_param);
image.magick(target_type);
image.quality(conf->jpeg_quality);
image.write(&blob);
vlob = (char*)blob.data();
vlob_length = blob.length();
}
catch(Magick::Exception& err) {
AP_LOG_ERR(rec, __FILE__ ": Magick failed: %s", err.what());
goto PASS_THRU;
}
if(image_hash) {
// Store to memcached...
memcached_return r = memcached_set(conf->memc, image_hash, strlen(image_hash), vlob, vlob_length, conf->expire, 0);
if(r==MEMCACHED_SUCCESS) {
AP_LOG_DEBUG(rec, "Stored to memcached: %s(len=%d)", image_hash, vlob_length);
} else {
AP_LOG_DEBUG(rec, "Can't store from memcached: %s(len=%d) - %s(%d)", image_hash, vlob_length,memcached_strerror(conf->memc, r), r);
}
}
WRITE_DATA:
AP_LOG_VERBOSE(rec, "-- Creating resize buckets.");
// Drop all content and headers related.
while(!APR_BRIGADE_EMPTY(in_bb)) {
apr_bucket* b = APR_BRIGADE_FIRST(in_bb);
apr_bucket_delete(b);
}
rec->eos_sent = 0;
rec->clength = 0;
unset_header(rec, "Content-Length");
unset_header(rec, "Content-Encoding");
unset_header(rec, "Last-Modified");
unset_header(rec, "ETag");
// Start resize bucket.
{
apr_off_t remain = vlob_length, offset = 0;
while(remain>0) {
apr_off_t bs = (remain<AP_MAX_SENDFILE)? remain: AP_MAX_SENDFILE;
char* heap = (char*)malloc(bs);
memcpy(heap, vlob+offset, bs);
apr_bucket* b = apr_bucket_heap_create(heap, bs, free, in_bb-> bucket_alloc);
APR_BRIGADE_INSERT_TAIL(in_bb, b);
remain -= bs;
offset += bs;
}
APR_BRIGADE_INSERT_TAIL(in_bb, apr_bucket_eos_create(in_bb->bucket_alloc));
ap_set_content_length(rec, vlob_length);
if(cache_hit) free(vlob);
}
AP_LOG_VERBOSE(rec, "-- Create done.");
PASS_THRU:
AP_LOG_VERBOSE(rec, "-- Filter done.");
ap_remove_output_filter(f);
return ap_pass_brigade(f->next, in_bb);
}
void PipelineStabTransform::onInput(InputImageInfo info, Magick::Image image) {
try {
if (!initialized) {
init(image);
}
if (image.rows() != height || image.columns() != width) {
throw runtime_error(QString("Not uniform image size! %").arg(info.file.fileName()).toStdString());
}
Q_ASSERT(image.baseColumns() == width && image.baseRows() == height);
Magick::Blob blob;
// set raw RGBS output format & convert it into a Blob
if (image.depth() > 8)
*err << "Warning: we lost some information by converting to 8bit depth (now " << image.depth() << ")" << endl;
image.depth(8);
image.magick("RGB");
image.write(&blob);
Q_ASSERT(blob.length() == image.baseColumns() * image.baseRows() * 3);
// inframe
VSFrame inframe;
size_t dataLen = blob.length();
inframe.data[0] = (uint8_t*) blob.data();
inframe.linesize[0] = image.baseColumns() * 3; // TODO: it is correct?
// outframe
uint8_t* data = new uint8_t[dataLen];
//memcpy(data, blob.data(), dataLen);
VSFrame outframe;
outframe.data[0] = data;
outframe.linesize[0] = image.baseColumns() * 3; // TODO: it is correct?
if (vsTransformPrepare(&td, &inframe, &outframe) != VS_OK) {
throw runtime_error("Failed to prepare transform");
}
Q_ASSERT(vsTransformGetSrcFrameInfo(&td)->planes == 1);
vsDoTransform(&td, vsGetNextTransform(&td, &trans));
vsTransformFinish(&td);
Magick::Geometry g(width, height);
Magick::Blob oblob(data, dataLen);
Magick::Image oimage;
oimage.size(g);
oimage.depth(8);
oimage.magick("RGB");
oimage.read(oblob);
delete[] data;
info.luminance = -1;
emit input(info, oimage);
} catch (exception &e) {
emit error(e.what());
}
}
