// *****************************************************************************
// Main
int main(int argc, char* const argv[])
{
try {
// Handle command line arguments
Params params;
if (params.getopt(argc, argv)) {
params.usage();
return 1;
}
if (params.help_) {
params.help();
return 2;
}
// Use MemIo to increase test coverage.
Exiv2::BasicIo::AutoPtr fileIo(new Exiv2::FileIo(params.read_));
Exiv2::BasicIo::AutoPtr memIo(new Exiv2::MemIo);
memIo->transfer(*fileIo);
Exiv2::Image::AutoPtr readImg = Exiv2::ImageFactory::open(memIo);
assert(readImg.get() != 0);
readImg->readMetadata();
Exiv2::Image::AutoPtr writeImg = Exiv2::ImageFactory::open(params.write_);
assert(writeImg.get() != 0);
if (params.preserve_) writeImg->readMetadata();
if (params.iptc_) {
writeImg->setIptcData(readImg->iptcData());
}
if (params.exif_) {
writeImg->setExifData(readImg->exifData());
}
if (params.comment_) {
writeImg->setComment(readImg->comment());
}
if (params.xmp_) {
writeImg->setXmpData(readImg->xmpData());
}
try {
writeImg->writeMetadata();
}
catch (const Exiv2::AnyError&) {
std::cerr << params.progname() <<
": Could not write metadata to (" << params.write_ << ")\n";
return 8;
}
return 0;
}
catch (Exiv2::AnyError& e) {
std::cerr << "Caught Exiv2 exception '" << e << "'\n";
return 10;
}
}
bool ExifHasher::HashExif(const std::string& path,
unsigned char* sha1_hash) const {
FD fd;
sys_call_rv(fd, open, path.c_str(), O_RDONLY);
struct stat stat_buf;
sys_call(fstat, fd, &stat_buf);
void* memblock;
sys_call2_rv(NULL, memblock, mmap, NULL, stat_buf.st_size, PROT_READ,
MAP_PRIVATE, fd, 0);
auto bytes = static_cast<const unsigned char*>(memblock);
Exiv2::Image::AutoPtr image;
try {
image = Exiv2::ImageFactory::open(bytes, stat_buf.st_size);
} catch (const std::exception& e) {
std::cerr << "Error: " << e.what() << std::endl;
return false;
}
if (image.get() != 0)
image->readMetadata();
else
std::cerr << "Warning: EXIF not found in: " << path << std::endl;
sys_call(munmap, memblock, stat_buf.st_size);
fd.Close();
if (image.get() == 0)
return false;
const auto& exifData = image->exifData();
if (!exifData.empty()) {
std::ostringstream oss;
auto end = exifData.end();
for (auto i = exifData.begin(); i != end; ++i) {
// std::cerr << i->key() << " (" << i->count() << ")" << ": " <<
// i->value() << std::endl;
oss << i->key() << i->value();
}
const std::string& exif_str = oss.str();
SHA1(reinterpret_cast<const unsigned char*>(exif_str.c_str()),
exif_str.size(), sha1_hash);
return true;
} else {
std::cerr << "Warning: EXIF not found in: " << path << std::endl;
}
return false;
}
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
assert(image.get() != 0);
image->readMetadata();
Exiv2::XmpData xmpData;
Exiv2::copyExifToXmp(image->exifData(), xmpData);
Exiv2::ExifData exifData;
Exiv2::copyXmpToExif(xmpData, exifData);
image->setXmpData(xmpData);
image->setExifData(exifData);
image->writeMetadata();
return 0;
}
catch (Exiv2::AnyError& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return -1;
}
void write(const std::string& file, Exiv2::ExifData& ed)
{
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(file);
assert (image.get() != 0);
image->setExifData(ed);
image->writeMetadata();
}
Exiv2::ExifData getExifFromPath(char* filename) {
qDebug() << "Trying to read EXIF for" << filename;
try {
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(filename);
assert(image.get() != 0);
image->readMetadata();
Exiv2::ExifData &exifData = image->exifData();
if (exifData.empty()) {
std::string error(filename);
error += ": No Exif data found in the file";
//TODO Translate
//throw Exiv2::Error(1, error);
}
return exifData;
} catch (Exiv2::Error& e) {
Exiv2::ExifData exifData;
qCritical() << "Caught Exiv2 exception '" << e.what();
//TODO Translate
return exifData;
}
}
void print(const std::string& file)
{
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(file);
assert(image.get() != 0);
image->readMetadata();
Exiv2::ExifData &ed = image->exifData();
Exiv2::ExifData::const_iterator end = ed.end();
for (Exiv2::ExifData::const_iterator i = ed.begin(); i != end; ++i) {
std::cout << std::setw(45) << std::setfill(' ') << std::left
<< i->key() << " "
<< "0x" << std::setw(4) << std::setfill('0') << std::right
<< std::hex << i->tag() << " "
<< std::setw(12) << std::setfill(' ') << std::left
<< i->ifdName() << " "
<< std::setw(9) << std::setfill(' ') << std::left
<< i->typeName() << " "
<< std::dec << std::setw(3)
<< std::setfill(' ') << std::right
<< i->count() << " "
<< std::dec << i->value()
<< "\n";
}
}
void ExifReaderWriter::saveExifGps(QString pictureName, double latitude, double longitude, double altitude)
{
qDebug() << "saveExifGps" << pictureName << latitude << longitude << altitude;
Exiv2::Image::AutoPtr image = openExif(pictureName);
if(image.get() == 0)
return;
if(image->exifData().empty())
{
Exiv2::ExifData exifDataTmp;
image->setExifData(exifDataTmp);
}
Exiv2::ExifData &exifData = image->exifData();
writeData(exifData, "Exif.GPSInfo.GPSLatitude", exifLatLonString(latitude));
writeData(exifData, "Exif.GPSInfo.GPSLongitude", exifLatLonString(longitude));
writeData(exifData, "Exif.GPSInfo.GPSLatitudeRef", (latitude<0 ? "S" : "N"));
writeData(exifData, "Exif.GPSInfo.GPSLongitudeRef", (longitude<0 ? "W" : "E"));
if(altitude > -999)
{
writeData(exifData, "Exif.GPSInfo.GPSAltitude", (QString("%1/%2").arg(abs(round(altitude * 1000))).arg(1000)));
writeData(exifData, "Exif.GPSInfo.GPSAltitudeRef", (altitude<0 ? "1" : "0"));
}
image->writeMetadata();
}
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
assert(image.get() != 0);
image->readMetadata();
const std::string& xmpPacket = image->xmpPacket();
if (xmpPacket.empty()) {
std::string error(argv[1]);
error += ": No XMP packet found in the file";
throw Exiv2::Error(1, error);
}
std::cout << xmpPacket << "\n";
return 0;
}
catch (Exiv2::AnyError& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return -1;
}
bool ptImageHelper::TransferExif(const QString ASourceFile, const QString ATargetFile)
{
if (ASourceFile == ATargetFile ||
ASourceFile.trimmed().isEmpty() ||
ATargetFile.trimmed().isEmpty())
return false;
try {
if (Exiv2::ImageFactory::getType(ASourceFile.toLocal8Bit().data()) == Exiv2::ImageType::none)
return false;
Exiv2::Image::AutoPtr hSourceImage = Exiv2::ImageFactory::open(ASourceFile.toLocal8Bit().data());
if (!hSourceImage.get()) return false;
hSourceImage->readMetadata();
Exiv2::Image::AutoPtr hTargetImage = Exiv2::ImageFactory::open(ATargetFile.toLocal8Bit().data());
hTargetImage->clearMetadata();
hTargetImage->setMetadata(*hSourceImage);
hTargetImage->writeMetadata();
return true;
} catch (Exiv2::AnyError& Error) {
if (Settings->GetInt("JobMode") == 0) {
ptMessageBox::warning(0 ,"Exiv2 Error","No exif data written!\nCaught Exiv2 exception '" + QString(Error.what()) + "'\n");
} else {
std::cout << "Caught Exiv2 exception '" << Error << "'\n";
}
}
return false;
}
int populateMetaExif(std::string file, std::string plate)
{
try
{
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(file);
std::string comment = plate + ' '+ "LOT50"; //Add code to get information about lot
if(!image.get())
{
throw Exiv2::Error(1, "Failed to open image");
}
image->readMetadata();
Exiv2::ExifData &exifData = image->exifData();
exifData["Exif.Photo.UserComment"]= comment;
//std::cout<< "Writing Exiv User Comment "<< exifData["Exif.Image.ImageDescription"] <<"\n";
image->writeMetadata();
} catch (Exiv2::AnyError& e) {
std::cout << "Problem Writing Metadata '" << e << "'\n";
return -1;
}
return 0;
}
/** \fn ImageUtils::GetExifValue(const QString &, const QString &, bool *)
* \brief Reads and returns the value of an exif tag in a file
* \param fileName The filename that holds the exif data
* \param exifTag The key that shall be updated
* \param ok Will be set to true if the reading was ok, otherwise false
* \return The value of the exif tag or an empty string
*/
QString ImageUtils::GetExifValue(const QString &fileName,
const QString &exifTag,
bool *ok)
{
// Assume the exif reading fails
*ok = false;
// default value
QString value("");
try
{
Exiv2::Image::AutoPtr image =
Exiv2::ImageFactory::open(fileName.toLocal8Bit().constData());
if (image.get())
{
image->readMetadata();
Exiv2::ExifData &exifData = image->exifData();
if (!exifData.empty())
{
Exiv2::Exifdatum &datum =
exifData[exifTag.toLocal8Bit().constData()];
value = QString::fromStdString(datum.toString());
if (!value.isEmpty())
{
*ok = true;
}
else
{
LOG(VB_GENERAL, LOG_ERR,
QString("Exiv2 error: No tag found, file %1, tag %2")
.arg(fileName).arg(exifTag));
}
}
else
{
LOG(VB_GENERAL, LOG_ERR,
QString("Exiv2 error: No header, file %1, tag %2")
.arg(fileName).arg(exifTag));
}
}
else
{
LOG(VB_GENERAL, LOG_ERR,
QString("Exiv2 error: Could not open file, file %1, tag %2")
.arg(fileName).arg(exifTag));
}
}
catch (Exiv2::Error& e)
{
LOG(VB_GENERAL, LOG_ERR,
QString("Exiv2 exception %1, file %2, tag %3")
.arg(e.what()).arg(fileName).arg(exifTag));
}
return value;
}
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
const char* path=argv[1];
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(path);
assert(image.get() != 0);
image->readMetadata();
Jzon::Object root;
const char* FS="FS";
Jzon::Object fs ;
root.Add (FS,fs) ;
fileSystemPush(path,root.Get(FS));
Exiv2::ExifData &exifData = image->exifData();
for ( ExifData::const_iterator i = exifData.begin(); i != exifData.end() ; ++i ) {
std::string key ;
push(objectForKey(i->key(),key,root),key,i);
}
Exiv2::IptcData &iptcData = image->iptcData();
for (Exiv2::IptcData::const_iterator i = iptcData.begin(); i != iptcData.end(); ++i) {
std::string key ;
push(objectForKey(i->key(),key,root),key,i);
}
Exiv2::XmpData &xmpData = image->xmpData();
for (Exiv2::XmpData::const_iterator i = xmpData.begin(); i != xmpData.end(); ++i) {
std::string key ;
push(objectForKey(i->key(),key,root),key,i);
}
/*
This is only for testing long paths
{
ExifData::const_iterator i = exifData.begin();
std::string key;
push(objectForKey("This.Is.A.Rather.Long.Path.Key",key,root),key,i);
}
*/
Jzon::Writer writer(root,Jzon::StandardFormat);
writer.Write();
std::cout << writer.GetResult() << std::endl;
return 0;
}
//catch (std::exception& e) {
//catch (Exiv2::AnyError& e) {
catch (Exiv2::Error& e) {
std::cout << "Caught Exiv2 exception '" << e.what() << "'\n";
return -1;
}
bool imwrite_tiff(matrix<unsigned short> output, string outputfilename,
Exiv2::ExifData exifData)
{
int xsize, ysize;
xsize = output.nc()/3;
ysize = output.nr();
outputfilename = outputfilename + ".tif";
TIFF *out = TIFFOpen(outputfilename.c_str(),"w");
if (!out)
{
cerr << "Can't open file for writing" << endl;
return 1;
}
TIFFSetField(out, TIFFTAG_IMAGEWIDTH, xsize);
TIFFSetField(out, TIFFTAG_IMAGELENGTH, ysize);
TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, 3); //RGB
TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 16);
TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); // set the origin of the image.
//Magic below
TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(out, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
//End Magic
tsize_t linebytes = 3 * xsize * 2;//Size in bytes of a line
unsigned short *buf = NULL;
buf =(unsigned short *)_TIFFmalloc(linebytes);
for (int j = 0; j < ysize; j++)
{
for(int i = 0; i < xsize; i ++)
{
buf[i*3 ] = output(j,i*3 );
buf[i*3+1] = output(j,i*3+1);
buf[i*3+2] = output(j,i*3+2);
}
if (TIFFWriteScanline(out, buf, j, 0) < 0)
break;
}
(void) TIFFClose(out);
if (buf)
_TIFFfree(buf);
exifData["Exif.Image.Orientation"] = 1;//set all images to unrotated
exifData["Exif.Image.ImageWidth"] = output.nr();
exifData["Exif.Image.ImageLength"] = output.nc()/3;
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(outputfilename.c_str());
assert(image.get() != 0);
image->setExifData(exifData);
//image->writeMetadata();
return 0;
}
// Returns empty string if the destination subdirectory could not be determined
// for the supplied source file.
std::string build_dest(const fs::path &source_file)
{
std::string dest;
Exiv2::Image::AutoPtr image;
try {
image = Exiv2::ImageFactory::open(source_file.string());
image->readMetadata();
}
catch(const Exiv2::AnyError&) {
// No metadata, let things continue to try file info
}
std::vector<PathPart>::iterator iter = g_path_parts.begin();
std::vector<PathPart>::iterator end = g_path_parts.end();
for( ; iter != end; ++iter) {
dest += iter->pre;
std::string result;
const Pattern *pat = iter->pat;
for(unsigned fx = 0; fx < g_run_order.size(); ++fx) {
if(g_run_order[fx] != -1 && pat->funcs[g_run_order[fx]]) {
if(g_run_order[fx] == FILE_SLOT) {
// Always run file operations
result = pat->funcs[g_run_order[fx]](image.get(), source_file);
}
else if(image.get()) {
// No point in running metadata operations without an image
result = pat->funcs[g_run_order[fx]](image.get(), source_file);
}
if(result.length())
break;
}
}
// If we found no data, even for part of pattern, give up and
// return no destination
if(!result.length())
return result;
dest += (result + iter->post);
}
return dest;
}
int RemoveGPSExif(const char* File, int NoChangeMtime)
{
struct stat statbuf;
struct stat statbuf2;
struct utimbuf utb;
if (NoChangeMtime)
stat(File, &statbuf);
// Open the file and start reading.
Exiv2::Image::AutoPtr Image;
try {
Image = Exiv2::ImageFactory::open(File);
} catch (Exiv2::Error e) {
DEBUGLOG("Failed to open file %s.\n", File);
return 0;
}
Image->readMetadata();
if (Image.get() == NULL)
{
// It failed if we got here.
DEBUGLOG("Failed to read file %s %s.\n",
File, Exiv2::strError().c_str());
return 0;
}
Exiv2::ExifData &ExifInfo = Image->exifData();
if (ExifInfo.count() == 0)
{
DEBUGLOG("No EXIF tags in file %s.\n", File);
return 0;
}
EraseGpsTags(ExifInfo);
try {
Image->writeMetadata();
} catch (Exiv2::Error e) {
DEBUGLOG("Failed to write to file %s.\n", File);
return 0;
}
if (NoChangeMtime)
{
stat(File, &statbuf2);
utb.actime = statbuf2.st_atime;
utb.modtime = statbuf.st_mtime;
utime(File, &utb);
}
return 1;
}
bool JpegContent::loadFromData(const QByteArray& data)
{
Exiv2::Image::AutoPtr image;
Exiv2ImageLoader loader;
if (!loader.load(data)) {
qCritical() << "Could not load image with Exiv2, reported error:" << loader.errorMessage();
}
image = loader.popImage();
return loadFromData(data, image.get());
}
char* ReadExifDate(const char* File, int* IncludesGPS)
{
// Open and read the file.
Exiv2::Image::AutoPtr Image;
try {
Image = Exiv2::ImageFactory::open(File);
} catch (Exiv2::Error e) {
DEBUGLOG("Failed to open file %s.\n", File);
return NULL;
}
Image->readMetadata();
if (Image.get() == NULL)
{
DEBUGLOG("Failed to read file %s %s.\n",
File, Exiv2::strError().c_str());
return NULL;
}
Exiv2::ExifData &ExifRead = Image->exifData();
// Read the tag out.
Exiv2::Exifdatum& Tag = ExifRead["Exif.Photo.DateTimeOriginal"];
// Check that the tag is not blank.
std::string Value = Tag.toString();
if (Value.length() == 0)
{
// No date/time stamp.
// Not good.
// Just return - above us will handle it.
return NULL;
}
// Copy the tag and return that.
char* Copy = strdup(Value.c_str());
// Check if we have GPS tags.
Exiv2::Exifdatum& GPSData = ExifRead["Exif.GPSInfo.GPSLatitude"];
if (GPSData.count() < 3)
{
// No valid GPS data.
*IncludesGPS = 0;
} else {
// Seems to include GPS data...
*IncludesGPS = 1;
}
// Now return, passing a pointer to the date string.
return Copy; // It's up to the caller to free this.
}
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
std::string file(argv[1]);
Exiv2::IptcData iptcData;
iptcData["Iptc.Application2.Headline"] = "The headline I am";
iptcData["Iptc.Application2.Keywords"] = "Yet another keyword";
iptcData["Iptc.Application2.DateCreated"] = "2004-8-3";
iptcData["Iptc.Application2.Urgency"] = uint16_t(1);
iptcData["Iptc.Envelope.ModelVersion"] = 42;
iptcData["Iptc.Envelope.TimeSent"] = "14:41:0-05:00";
iptcData["Iptc.Application2.RasterizedCaption"] = "230 42 34 2 90 84 23 146";
iptcData["Iptc.0x0009.0x0001"] = "Who am I?";
Exiv2::StringValue value;
value.read("very!");
iptcData["Iptc.Application2.Urgency"] = value;
std::cout << "Time sent: " << iptcData["Iptc.Envelope.TimeSent"] << "\n";
// Open image file
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(file);
if (image.get() == 0) {
std::string error(file);
error += " : Could not read file or unknown image type";
throw Exiv2::Error(error);
}
// Read existing metdata (so that exif will be preserved)
int rc = image->readMetadata();
if (rc) {
std::string error = Exiv2::Image::strError(rc, file);
throw Exiv2::Error(error);
}
// Replace Iptc data and write it back to the file
image->setIptcData(iptcData);
return image->writeMetadata();
}
catch (Exiv2::Error& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return -1;
}
// uses the exiv2 class to readout the exifdata from images
int ExifScout::showExifData(std::string a){
try {
Ui_MainWindow::textEdit->clear();
std::cerr << "ImageFactory::open ";
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(a);
std::cerr << "DONE\n";
assert(image.get() != 0);
std::cerr << "image->readMetadata() ";
image->readMetadata();
std::cerr << "DONE\n";
std::cerr << "Exiv2::ExifData& exifData = image->exifData() ";
Exiv2::ExifData exifData = image->exifData();
std::cerr << "DONE\n";
cout << "Number of found exiv2 data: " << exifData.count() << endl;
if (exifData.empty()) {
Ui_MainWindow::textEdit->setPlainText("No Exif data found in file");
return 1;
}
Exiv2::ExifData::const_iterator end = exifData.end();
std::cerr << "Generate the exif-output ";
QString output;
for (Exiv2::ExifData::const_iterator i = exifData.begin(); i != end; ++i) {
std::string tagname = i->tagName();
if(tagname != std::string("MakerNote") and
tagname.substr(0,2) != "0x"){
// Print out the exif-data in the QtextEdit Field
std::ostringstream oss;
oss << i->tagName() << ":\n " << i->value() << "\n";
output = output+(QString)oss.str().c_str();
}
}
std::cerr << "Done\n";
Ui_MainWindow::textEdit->setPlainText(output);
return 0;
}
//catch (std::exception& e) {
//catch (Exiv2::AnyError& e) {
catch (Exiv2::Error& e) {
std::cout << "Caught Exiv2 exception '" << e.what() << "'\n";
return -1;
}
}
// *****************************************************************************
// Main
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
assert (image.get() != 0);
image->readMetadata();
Exiv2::ExifData &exifData = image->exifData();
/*
Exiv2 uses a CommentValue for Exif user comments. The format of the
comment string includes an optional charset specification at the beginning:
[charset=["]Ascii|Jis|Unicode|Undefined["] ]comment
Undefined is used as a default if the comment doesn't start with a charset
definition.
Following are a few examples of valid comments. The last one is written to
the file.
*/
exifData["Exif.Photo.UserComment"]
= "charset=\"Unicode\" An Unicode Exif comment added with Exiv2";
exifData["Exif.Photo.UserComment"]
= "charset=\"Undefined\" An undefined Exif comment added with Exiv2";
exifData["Exif.Photo.UserComment"]
= "Another undefined Exif comment added with Exiv2";
exifData["Exif.Photo.UserComment"]
= "charset=Ascii An ASCII Exif comment added with Exiv2";
std::cout << "Writing user comment '"
<< exifData["Exif.Photo.UserComment"]
<< "' back to the image\n";
image->writeMetadata();
return 0;
}
catch (Exiv2::AnyError& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return -1;
}
int ImgTagJson::literal()
{
Exiv2::Image::AutoPtr image;
try
{
image = Exiv2::ImageFactory::open(fname);
}
catch (Exiv2::Error& e)
{
cerr << "Invalid file: " << fname << endl;
return 6;
}
if (image.get() == 0) return 1;
image->readMetadata();
JSONNODE *l = json_new(JSON_NODE);
if (exif)
{
JSONNODE *e = this->genLitExif(image);
if (e != NULL) json_push_back(l, e);
}
if (iptc)
{
JSONNODE *i = this->genLitIptc(image);
if (i != NULL) json_push_back(l, i);
}
if (xmp)
{
JSONNODE *x = this->genLitXmp(image);
if (x != NULL) json_push_back(l, x);
}
JSONNODE *chksum = getChkSum();
if (chksum != NULL)
json_push_back(l, chksum);
cout << json_write_formatted(l) << endl;
json_delete(l);
return 0;
}
void CmsProfileTest::testLoadFromExiv2Image()
{
QFETCH(QString, fileName);
Exiv2::Image::AutoPtr image;
{
QByteArray data;
QString path = pathForTestFile(fileName);
qWarning() << path;
QFile file(path);
QVERIFY(file.open(QIODevice::ReadOnly));
data = file.readAll();
Exiv2ImageLoader loader;
QVERIFY(loader.load(data));
image = loader.popImage();
}
Cms::Profile::Ptr ptr = Cms::Profile::loadFromExiv2Image(image.get());
QVERIFY(!ptr.isNull());
}
// tries to find a specified exif tag in a specified file
QString ExifScout::getExifData(QString fname, QString etag){
std::string filename = fname.toAscii().data();
std::string exiftag = etag.toAscii().data();
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(filename);
assert(image.get() != 0);
image->readMetadata();
Exiv2::ExifData exifData = image->exifData();
if (!exifData.empty()) {
Exiv2::ExifData::const_iterator end = exifData.end();
QString output;
for (Exiv2::ExifData::const_iterator i = exifData.begin(); i != end; ++i) {
if(i->tagName()==exiftag){
std::ostringstream oss;
oss << i->value();
return (QString)oss.str().c_str();
}
}
}
return NULL;
}
Exiv2::Image::AutoPtr ExifReaderWriter::openExif(QString pictureName)
{
Exiv2::Image::AutoPtr image;
try{
#ifdef _WIN32
image = Exiv2::ImageFactory::open( std::string(pictureName.toLocal8Bit()));
#else
image = Exiv2::ImageFactory::open( std::string(pictureName.toUtf8()));
#endif
}
catch (Exiv2::Error& e) {
//std::cerr << "Caught Exiv2 exception 1 '" << e.what() << "'\n";
return image;
}
if(image.get()){
image->readMetadata();
}
return image;
}
bool Exiv2ReadingWorker::readMetadata(Models::ArtworkMetadata *artwork, ImportDataResult &importResult) {
const QString &filepath = artwork->getFilepath();
#if defined(Q_OS_WIN)
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(filepath.toStdWString());
#else
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(filepath.toStdString());
#endif
Q_ASSERT(image.get() != NULL);
image->readMetadata();
Exiv2::XmpData &xmpData = image->xmpData();
Exiv2::ExifData &exifData = image->exifData();
Exiv2::IptcData &iptcData = image->iptcData();
QString iptcEncoding = getIptcCharset(iptcData).toUpper();
bool isIptcUtf8 = (iptcEncoding == QLatin1String("UTF-8")) || (iptcEncoding == QLatin1String("UTF8"));
importResult.FilePath = filepath;
importResult.Description = retrieveDescription(xmpData, exifData, iptcData, isIptcUtf8);
importResult.Title = retrieveTitle(xmpData, exifData, iptcData, isIptcUtf8);
importResult.Keywords = retrieveKeywords(xmpData, exifData, iptcData, isIptcUtf8);
importResult.DateTimeOriginal = retrieveDateTime(xmpData, exifData, iptcData, isIptcUtf8);
MetadataSavingCopy copy;
if (copy.readFromFile(filepath)) {
importResult.BackupDict = copy.getInfo();
}
QFileInfo fi(filepath);
importResult.FileSize = fi.size();
Models::ImageArtwork *imageArtwork = dynamic_cast<Models::ImageArtwork*>(artwork);
if (imageArtwork != NULL) {
QImageReader reader(filepath);
importResult.ImageSize = reader.size();
}
return true;
}
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
assert (image.get() != 0);
image->readMetadata();
Exiv2::IptcData &iptcData = image->iptcData();
if (iptcData.empty()) {
std::string error(argv[1]);
error += ": No IPTC data found in the file";
throw Exiv2::Error(1, error);
}
Exiv2::IptcData::iterator end = iptcData.end();
for (Exiv2::IptcData::iterator md = iptcData.begin(); md != end; ++md) {
std::cout << std::setw(44) << std::setfill(' ') << std::left
<< md->key() << " "
<< "0x" << std::setw(4) << std::setfill('0') << std::right
<< std::hex << md->tag() << " "
<< std::setw(9) << std::setfill(' ') << std::left
<< md->typeName() << " "
<< std::dec << std::setw(3)
<< std::setfill(' ') << std::right
<< md->count() << " "
<< std::dec << md->value()
<< std::endl;
}
return 0;
}
catch (Exiv2::AnyError& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return -1;
}
void ImageResolution::readexiv(char const *fn) {
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(fn);
if (!image.get())
return;
image->readMetadata();
Exiv2::ExifData &exifData = image->exifData();
if (exifData.empty())
return;
Exiv2::ExifData::const_iterator end = exifData.end();
bool havex = false;
bool havey = false;
bool haveunit = false;
int unit;
for (Exiv2::ExifData::const_iterator i = exifData.begin(); i != end; ++i) {
if (ok_)
break;
if (i->tag()==0x011a) {
// X Resolution
x_ = i->toFloat();
havex = true;
} else if (i->tag()==0x011b) {
// Y Resolution
y_ = i->toFloat();
havey = true;
} else if (i->tag()==0x0128) {
unit = i->toLong();
}
ok_ = havex && havey && haveunit;
}
if (haveunit) {
if (unit==3) {
x_ *= 2.54;
y_ *= 2.54;
}
}
ok_ = havex && havey;
}
int main(int argc, char* const argv[])
try {
if (argc != 2) {
std::cout << "Usage: " << argv[0] << " file\n";
return 1;
}
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(argv[1]);
if (image.get() == 0) {
std::string error(argv[1]);
error += " : Could not read file or unknown image type";
throw Exiv2::Error(error);
}
// Load existing metadata
int rc = image->readMetadata();
if (rc) {
std::string error = Exiv2::Image::strError(rc, argv[1]);
throw Exiv2::Error(error);
}
Exiv2::ExifData &exifData = image->exifData();
Exiv2::ExifData::const_iterator end = exifData.end();
for (Exiv2::ExifData::const_iterator i = exifData.begin(); i != end; ++i) {
std::cout << std::setw(53) << std::setfill(' ') << std::left
<< i->key() << " "
<< "0x" << std::setw(4) << std::setfill('0') << std::right
<< std::hex << i->tag() << " "
<< std::dec << i->value()
<< "\n";
}
return rc;
}
catch (Exiv2::Error& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return -1;
}
/** \fn ImageUtils::SetExifValue(const QString &, const QString &, const QString &, bool *)
* \brief Updates the exif tag in a file with the given value
* \param fileName The filename that holds the exif data
* \param exifTag The key that shall be updated
* \param value The new value of the exif tag
* \param ok Will be set to true if the update was ok, otherwise false
* \return True if the exif key exists, otherwise false
*/
void ImageUtils::SetExifValue(const QString &fileName,
const QString &exifTag,
const QString &value,
bool *ok)
{
// Assume the exif writing fails
*ok = false;
try
{
Exiv2::Image::AutoPtr image =
Exiv2::ImageFactory::open(fileName.toLocal8Bit().constData());
if (image.get())
{
Exiv2::ExifData exifData;
Exiv2::Exifdatum &datum = exifData[exifTag.toLocal8Bit().constData()];
datum.setValue(value.toLocal8Bit().constData());
image->setExifData(exifData);
image->writeMetadata();
*ok = true;
}
else
{
LOG(VB_GENERAL, LOG_ERR,
QString("Exiv2 error: Could not open file, file %1, tag %2")
.arg(fileName).arg(exifTag));
}
}
catch (Exiv2::Error& e)
{
LOG(VB_GENERAL, LOG_ERR,
QString("Exiv2 exception %1, file %2, tag %3, value %4")
.arg(e.what()).arg(fileName).arg(exifTag).arg(value));
}
}
bool tag_location( const std::string &filename, const location &loc)
{
bool result = false;
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open( filename);
if (!image.get()) throw std::runtime_error( "could not open image file " + filename + " for metadata tags\n");
image->readMetadata();
Exiv2::ExifData data = image->exifData();
if (data.findKey( Exiv2::ExifKey("Exif.GPSInfo.GPSLatitude")) == data.end())
{
add_exif_coordinate( data, "Exif.GPSInfo.GPSLatitude", std::abs( loc.latitude));
add_exif_coordinate( data, "Exif.GPSInfo.GPSLongitude", std::abs( loc.longitude));
data["Exif.GPSInfo.GPSLatitudeRef"] = loc.latitude < 0 ? "S":"N";
data["Exif.GPSInfo.GPSLongitudeRef"] = loc.longitude < 0 ? "W":"E";
Exiv2::byte version[] = { 2, 0, 0, 0};
data["Exif.GPSInfo.GPSVersionID"].getValue()->read( version, 4, Exiv2::invalidByteOrder);
image->setExifData( data);
image->writeMetadata();
result = true;
}
return result;
}
