/**
* XPath composition utilities using the <code>XmpPathFactory</code>.
* @throws XmpException Forwards exceptions
*/
private static void CoverPathCreation()
{
writeMajorLabel("XPath composition utilities");
var meta = XmpMetaFactory.Create();
meta.AppendArrayItem(TestData.NS1, "ArrayProp", new PropertyOptions {
IsArray = true
}, "Item 1", null);
string path = XmpPathFactory.ComposeArrayItemPath("ArrayProp", 2);
log.WriteLine("composeArrayItemPath ArrayProp[2] = " + path);
meta.SetProperty(TestData.NS1, path, "new ns1:ArrayProp[2] value");
path = "StructProperty";
path += XmpPathFactory.ComposeStructFieldPath(TestData.NS2, "Field3");
log.WriteLine("composeStructFieldPath StructProperty/ns2:Field3 = " + path);
meta.SetProperty(TestData.NS1, path, "new ns1:StructProp/ns2:Field3 value");
path = "QualProp";
path += XmpPathFactory.ComposeQualifierPath(TestData.NS2, "Qual");
log.WriteLine("composeStructFieldPath QualProp/?ns2:Qual = " + path);
meta.SetProperty(TestData.NS1, path, "new ns1:QualProp/?ns2:Qual value");
meta.SetLocalizedText(TestData.NS1, "AltTextProp", null, "en-US", "initival value");
path = "AltTextProp";
path += XmpPathFactory.ComposeQualifierPath(XmpConstants.NsXml, "lang");
log.WriteLine("composeQualifierPath ns1:AltTextProp/?xml:lang = " + path);
meta.SetProperty(TestData.NS1, path, "new ns1:AltTextProp/?xml:lang value");
printXmpMeta(meta, "Modified simple RDF");
}
/**
* Test simple constructors and parsing, setting the instance ID
* @throws XmpException Forwards exceptions
*/
private static void CoverCreatingXmp()
{
writeMajorLabel("Test simple constructors and parsing, setting the instance ID");
var meta1 = XmpMetaFactory.Create();
printXmpMeta(meta1, "Empty XMP object");
var meta2 = XmpMetaFactory.Create();
meta2.SetObjectName("New object name");
printXmpMeta(meta2, "XMP object with name");
var meta3 = XmpMetaFactory.ParseFromString(TestData.RDF_COVERAGE);
printXmpMeta(meta3, "Construct and parse from buffer");
meta3.SetProperty(XmpConstants.NsXmpMm, "InstanceID", "meta2:Original");
printXmpMeta(meta3, "Add instance ID");
XmpMeta meta4 = (XmpMeta)meta3.Clone();
meta4.SetProperty(XmpConstants.NsXmpMm, "InstanceID", "meta2:Clone");
printXmpMeta(meta3, "Clone and add instance ID");
}
private void WriteXmpMetaData(string imageFilePath, MasterImage masterImage, bool alwaysWriteMetadata, bool preview)
{
bool writeMetadata = false;
IXmpMeta xmp = XmpMetaFactory.Create();
if ((!String.IsNullOrEmpty(masterImage.Caption) && !IsEquivalent(masterImage.Caption, imageFilePath)) || alwaysWriteMetadata)
{
xmp.AppendArrayItem(XmpConstants.NsDC, "dc:title", new PropertyOptions {
IsArrayAlternate = true
}, masterImage.Caption, null);
writeMetadata = true;
}
if (!String.IsNullOrEmpty(masterImage.Comment))
{
xmp.AppendArrayItem(XmpConstants.NsDC, "dc:description", new PropertyOptions {
IsArrayAlternate = true
}, masterImage.Comment, null);
writeMetadata = true;
}
if (masterImage.Rating != null && (int)masterImage.Rating > 0)
{
xmp.SetProperty(XmpConstants.NsXmp, "xmp:Rating", ((int)masterImage.Rating).ToString());
writeMetadata = true;
}
// TODO: Handle faces.
if (writeMetadata)
{
string metaFilePath = Path.ChangeExtension(imageFilePath, ".xmp");
if (File.Exists(metaFilePath))
{
Console.Error.WriteLine("ERROR: XMP meta file already exists, skipping '" + metaFilePath + "'.");
}
else if (!preview)
{
Directory.CreateDirectory(Path.GetDirectoryName(metaFilePath));
using (var stream = File.OpenWrite(metaFilePath))
{
XmpMetaFactory.Serialize(xmp, stream, new SerializeOptions {
OmitPacketWrapper = true
});
}
numMetadataFilesCreated++;
}
}
}
internal static IXmpMeta Get(ImageDetails details)
{
var xmp = XmpMetaFactory.Create();
var idNs = "https://id.parliament.uk/";
var schemaNs = $"{idNs}schema/";
XmpMetaFactory.SchemaRegistry.RegisterNamespace(idNs, "id");
XmpMetaFactory.SchemaRegistry.RegisterNamespace(schemaNs, "schema");
xmp.SetProperty(XmpConstants.NsIptccore, "CiAdrCity", "London");
xmp.SetProperty(XmpConstants.NsIptccore, "CiAdrCtry", "UK");
xmp.SetProperty(XmpConstants.NsIptccore, "CiAdrRegion", "London");
xmp.SetProperty(XmpConstants.NsIptccore, "CiEmailWork", "*****@*****.**");
xmp.SetProperty(XmpConstants.NsIptccore, "CiTelWork", "+447740424810");
xmp.SetProperty(XmpConstants.NsIptccore, "CiUrlWork", "http://www.mcandrewphoto.co.uk");
xmp.SetProperty(XmpConstants.NsPhotoshop, "Source", "Chris McAndrew / UK Parliament");
xmp.SetProperty(XmpConstants.NsPhotoshop, "Credit", "Chris McAndrew / UK Parliament (Attribution 3.0 Unported (CC BY 3.0))");
xmp.SetPropertyDate(XmpConstants.NsPhotoshop, "DateCreated", XmpDateTimeFactory.Create(2017, 6, 17, 11, 30, 41, 0));
xmp.SetProperty(XmpConstants.NsDC, "rights", "Attribution 3.0 Unported (CC BY 3.0)");
xmp.SetProperty(XmpConstants.NsDC, "title", $"{details.GivenName} {details.FamilyName}");
xmp.SetProperty(XmpConstants.NsDC, "description", $"{details.GivenName} {details.FamilyName} - UK Parliament official portraits 2017");
xmp.SetProperty(XmpConstants.NsDC, "creator", "Chris McAndrew / UK Parliament");
// <rdf:Description rdf:about="http://id.parliament.uk/IMAGE1" />
xmp.SetObjectName($"{idNs}{details.Id}");
// id:IMAGE1 a schema:Image
xmp.SetProperty(XmpConstants.NsRdf, "type", $"{schemaNs}Image", new PropertyOptions {
IsUri = true
});
// id:IMAGE1 schema:parlHasSubject id:PERSON1
xmp.SetProperty(schemaNs, "imageHasSubject", details.MemberUri, new PropertyOptions {
IsUri = true
});
// id:PERSON1 a schema:Person
xmp.SetQualifier(schemaNs, "imageHasSubject", XmpConstants.NsRdf, "type", $"{schemaNs}Person", new PropertyOptions {
IsUri = true
});
return(xmp);
}
/**
* Creates an XmpWriter.
* @param os
* @param utfEncoding
* @param extraSpace
* @throws IOException
*/
public XmpWriter(Stream os, String utfEncoding, int extraSpace)
{
outputStream = os;
serializeOptions = new SerializeOptions();
if (UTF16BE.Equals(utfEncoding) || UTF16.Equals(utfEncoding))
{
serializeOptions.EncodeUtf16Be = true;
}
else if (UTF16LE.Equals(utfEncoding))
{
serializeOptions.EncodeUtf16Le = true;
}
serializeOptions.Padding = extraSpace;
xmpMeta = XmpMetaFactory.Create();
xmpMeta.ObjectName = XmpConst.TAG_XMPMETA;
xmpMeta.ObjectName = "";
try {
xmpMeta.SetProperty(XmpConst.NS_DC, DublinCoreProperties.FORMAT, "application/pdf");
xmpMeta.SetProperty(XmpConst.NS_PDF, PdfProperties.PRODUCER, Version.GetInstance().GetVersion);
}
catch (XmpException) {}
}
/**
* Localized text set/get methods.
* @throws XmpException Forwards exceptions
*/
private void CoverLocalisedProperties()
{
WriteMajorLabel("Test setLocalizedText and getLocalizedText");
var meta = XmpMetaFactory.Create();
meta.SetLocalizedText(TestData.NS1, "AltText", "", "x-default", "default value");
PrintXmpMeta(meta, "Set x-default value");
meta.SetLocalizedText(TestData.NS1, "AltText", "en", "en-us", "en-us value");
PrintXmpMeta(meta, "Set en/en-us value");
meta.SetLocalizedText(TestData.NS1, "AltText", "en", "en-uk", "en-uk value");
PrintXmpMeta(meta, "Set en/en-uk value");
var property = meta.GetLocalizedText(TestData.NS1, "AltText", "en", "en-ca");
_log.WriteLine("getLocalizedText en/en-ca = " + property.Value + " (lang: " + property.Language + ", opt: " + property.Options.GetOptionsString() + ")");
property = meta.GetProperty(TestData.NS1, "AltText");
_log.WriteLine("getProperty ns1:AltText = " + property.Value + " (lang: " + property.Language + ", opt: " + property.Options.GetOptionsString() + ")");
}
/**
* Cover some basid set calls (including arrays and structs).
* @return Returns an <code>XmpMeta</code> object that is reused in the next examples.
* @throws XmpException Forwards Exceptions
*/
private static IXmpMeta CoverSetPropertyMethods()
{
// Basic set/get methods
writeMajorLabel("Test SetProperty and related methods");
var meta = XmpMetaFactory.Create();
meta.SetProperty(TestData.NS1, "Prop", "Prop value");
meta.SetProperty(TestData.NS1, "ns1:XMLProp", "<PropValue/>");
meta.SetProperty(TestData.NS1, "ns1:URIProp", "URI:value/", new PropertyOptions {
IsUri = true
});
meta.AppendArrayItem(TestData.NS1, "Bag", new PropertyOptions {
IsArray = true
}, "BagItem value", null);
meta.AppendArrayItem(TestData.NS1, "ns1:Seq", new PropertyOptions {
IsArrayOrdered = true
}, "SeqItem value", null);
meta.AppendArrayItem(TestData.NS1, "ns1:Alt", new PropertyOptions {
IsArrayAlternate = true
}, "AltItem value", null);
meta.SetArrayItem(TestData.NS1, "Bag", 1, "BagItem 3");
meta.InsertArrayItem(TestData.NS1, "ns1:Bag", 1, "BagItem 1");
meta.InsertArrayItem(TestData.NS1, "ns1:Bag", 2, "BagItem 2");
meta.AppendArrayItem(TestData.NS1, "Bag", "BagItem 4");
meta.SetStructField(TestData.NS1, "Struct", TestData.NS2, "Field1", "Field1 value");
meta.SetStructField(TestData.NS1, "ns1:Struct", TestData.NS2, "Field2", "Field2 value");
meta.SetStructField(TestData.NS1, "ns1:Struct", TestData.NS2, "Field3", "Field3 value");
printXmpMeta(meta, "A few basic set property calls");
// -----------------------------------------------------------------------------------------
// Add some properties with qualifier
writeMinorLabel("Add some properties with qualifier");
log.WriteLine("CountArrayItems Bag = " + meta.CountArrayItems(TestData.NS1, "Bag"));
meta.SetProperty(TestData.NS1, "QualProp1", "Prop value");
meta.SetQualifier(TestData.NS1, "QualProp1", TestData.NS2, "Qual1", "Qual1 value");
meta.SetProperty(TestData.NS1, "QualProp1/?ns2:Qual3", "Qual3 value");
meta.SetProperty(TestData.NS1, "QualProp1/?xml:lang", "x-qual");
meta.SetProperty(TestData.NS1, "QualProp2", "Prop value");
meta.SetQualifier(TestData.NS1, "QualProp2", XmpConstants.NsXml, "lang", "en-us");
meta.SetProperty(TestData.NS1, "QualProp2/@xml:lang", "x-attr");
meta.SetProperty(TestData.NS1, "QualProp3", "Prop value");
meta.SetQualifier(TestData.NS1, "ns1:QualProp3", XmpConstants.NsXml, "xml:lang", "en-us");
meta.SetQualifier(TestData.NS1, "ns1:QualProp3", TestData.NS2, "ns2:Qual", "Qual value");
meta.SetProperty(TestData.NS1, "QualProp4", "Prop value");
meta.SetQualifier(TestData.NS1, "QualProp4", TestData.NS2, "Qual", "Qual value");
meta.SetQualifier(TestData.NS1, "QualProp4", XmpConstants.NsXml, "lang", "en-us");
printXmpMeta(meta, "Add some qualifiers");
meta.SetProperty(TestData.NS1, "QualProp1", "new value");
meta.SetProperty(TestData.NS1, "QualProp2", "new value");
meta.SetProperty(TestData.NS1, "QualProp3", "new value");
meta.SetProperty(TestData.NS1, "QualProp4", "new value");
printXmpMeta(meta, "Change values and keep qualifiers");
return(meta);
}
/**
* List predefined aliases, register new aliases and resolve aliases.
* @throws XmpException Forward exceptions
*/
private static void CoverAliasRegistry()
{
writeMajorLabel("Test alias registry and functions");
dumpAliases();
// Register new aliases
writeMinorLabel("Add ns2: to ns1: aliases");
dumpAliases();
// Resolve aliases
writeMinorLabel("Resolve ns2: to ns1: aliases");
var aliasInfo = registry.ResolveAlias(TestData.NS1, "SimpleActual");
log.WriteLine("ResolveAlias ns1:SimpleActual: " + aliasInfo + " (wrong way!)");
aliasInfo = registry.ResolveAlias(TestData.NS2, "SimpleAlias");
log.WriteLine("ResolveAlias ns2:SimpleAlias: " + aliasInfo);
log.WriteLine();
aliasInfo = registry.ResolveAlias(TestData.NS2, "BagAlias");
log.WriteLine("ResolveAlias ns2:BagAlias: " + aliasInfo);
aliasInfo = registry.ResolveAlias(TestData.NS2, "SeqAlias");
log.WriteLine("ResolveAlias ns2:SeqAlias: " + aliasInfo);
aliasInfo = registry.ResolveAlias(TestData.NS2, "AltAlias");
log.WriteLine("ResolveAlias ns2:AltAlias: " + aliasInfo);
aliasInfo = registry.ResolveAlias(TestData.NS2, "AltTextAlias");
log.WriteLine("ResolveAlias ns2:AltTextAlias: " + aliasInfo);
log.WriteLine();
aliasInfo = registry.ResolveAlias(TestData.NS2, "BagItemAlias");
log.WriteLine("ResolveAlias ns2:BagItemAlias: " + aliasInfo);
aliasInfo = registry.ResolveAlias(TestData.NS2, "SeqItemAlias");
log.WriteLine("ResolveAlias ns2:SeqItemAlias: " + aliasInfo);
aliasInfo = registry.ResolveAlias(TestData.NS2, "AltItemAlias");
log.WriteLine("ResolveAlias ns2:AltItemAlias: " + aliasInfo);
aliasInfo = registry.ResolveAlias(TestData.NS2, "AltTextItemAlias");
log.WriteLine("ResolveAlias ns2:AltTextItemAlias: " + aliasInfo);
log.WriteLine();
// set alias properties
writeMinorLabel("Test SetProperty through ns2: simple aliases");
var meta = XmpMetaFactory.Create();
meta.SetProperty(TestData.NS2, "SimpleAlias", "Simple value");
meta.SetProperty(TestData.NS2, "ns2:BagItemAlias", "BagItem value");
meta.SetProperty(TestData.NS2, "SeqItemAlias", "SeqItem value");
meta.SetProperty(TestData.NS2, "AltItemAlias", "AltItem value");
meta.SetProperty(TestData.NS2, "AltTextItemAlias", "AltTextItem value");
printXmpMeta(meta, "Check for aliases and bases");
// delete aliases
writeMinorLabel("Delete some ns2: to ns1: aliases");
dumpAliases();
}
