internal static XElement GenerateImageManifest
(int tileSize, int tileOverlap, string imageFormat, int imageWidth, int imageHeight)
{
XDocument doc;
XmlNamespaceManager namespaceManager;
using (var stream = AssemblyExtensions.OpenScopedResourceStream <Program> ("Template.dzi"))
using (var reader = XmlReader.Create(stream, ReaderSettings))
{
doc = XDocument.Load(reader);
namespaceManager = new XmlNamespaceManager(reader.NameTable);
namespaceManager.AddNamespace("dz", DeepZoomNamespace.NamespaceName);
}
var imageNode = doc.Root;
Debug.Assert(imageNode != null);
#region <Image TileSize="254" Overlap="1" Format="png">
imageNode.SetAttributeValue("TileSize", tileSize);
imageNode.SetAttributeValue("Overlap", tileOverlap);
imageNode.SetAttributeValue("Format", imageFormat);
#region <Size Width="800" Height="400" />
var sizeNode = imageNode.XPathSelectElement("dz:Size", namespaceManager);
sizeNode.SetAttributeValue("Width", imageWidth);
sizeNode.SetAttributeValue("Height", imageHeight);
#endregion
#endregion
return(imageNode);
}
public void Typical()
{
using (var ms = new MemoryStream())
using (var sw = new StreamWriter(ms))
{
XDocument doc;
XmlNamespaceManager namespaceManager;
using (var stream = AssemblyExtensions.OpenScopedResourceStream <CollectionWriter> ("Template.cxml"))
using (var reader = XmlReader.Create(stream))
{
doc = XDocument.Load(reader);
namespaceManager = new XmlNamespaceManager(reader.NameTable);
namespaceManager.AddNamespace("c", Namespaces.Collection.NamespaceName);
}
using (var cw = new CollectionWriter(ms, XmlWriterSettings, futureCw =>
{
futureCw.Flush();
sw.Write(ProgramTest.ExpectedAnsweredAndAccepted);
sw.Flush();
})
)
{
doc.Save(cw);
}
sw.Flush();
ProgramTest.AssertStreamsAreEqual <CollectionWriterTest> ("CollectionWithInjectedItems.cxml", ms);
}
}
public void ConvertToGdiPlusBitmap()
{
// arrange
BitmapSource bitmapSource;
const string fileName = "1200x1500.png";
using (var inputStream = AssemblyExtensions.OpenScopedResourceStream <BitmapSourceExtensionsTest> (fileName))
{
var decoder = new PngBitmapDecoder(
inputStream,
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default
);
bitmapSource = decoder.Frames[0];
}
// act
var bitmap = bitmapSource.ConvertToGdiPlusBitmap();
// assert
using (var actualStream = new MemoryStream())
{
bitmap.Save(actualStream, ImageFormat.Png);
ProgramTest.AssertStreamsAreEqual <BitmapSourceExtensionsTest> (fileName, actualStream);
}
}
internal XElement GenerateImageManifest()
{
XDocument doc;
XmlNamespaceManager namespaceManager;
using (var stream = AssemblyExtensions.OpenScopedResourceStream <Settings> ("Template.dzi"))
using (var reader = XmlReader.Create(stream, XmlReaderSettings))
{
doc = XDocument.Load(reader);
namespaceManager = new XmlNamespaceManager(reader.NameTable);
namespaceManager.AddNamespace("dz", Namespaces.DeepZoom2009.NamespaceName);
}
var imageNode = doc.Root;
Debug.Assert(imageNode != null);
#region <Image TileSize="254" Overlap="1" Format="png">
imageNode.SetAttributeValue("TileSize", TileSize);
imageNode.SetAttributeValue("Overlap", TileOverlap);
imageNode.SetAttributeValue("Format", PostImageEncoding.GetName());
#region <Size Width="800" Height="400" />
var sizeNode = imageNode.XPathSelectElement("dz:Size", namespaceManager);
sizeNode.SetAttributeValue("Width", ItemImageSize.Width);
sizeNode.SetAttributeValue("Height", ItemImageSize.Height);
#endregion
#endregion
return(imageNode);
}
internal static string LoadCommandText(string commandName)
{
using (var stream = AssemblyExtensions.OpenScopedResourceStream <DatabaseRepositoryBase> (commandName))
using (var reader = new StreamReader(stream))
{
var result = reader.ReadToEnd();
return(result);
}
}
public ProgramTest()
{
using (var stream = AssemblyExtensions.OpenScopedResourceStream <ProgramTest> ("TestTemplate.xaml"))
{
_testTemplate = (Page)XamlReader.Load(stream);
_testTemplate.Width = 800;
_testTemplate.Height = 400;
}
}
internal static XElement GenerateImageCollection(
IEnumerable <int> postIds,
string imageFormat,
string postFileNameFormat,
string relativePathToRoot,
int originalImageWidth,
int originalImageHeight
)
{
XDocument doc;
var namespaceManager = new XmlNamespaceManager(new NameTable());
namespaceManager.AddNamespace("dz", DeepZoom2008Namespace.NamespaceName);
using (var stream = AssemblyExtensions.OpenScopedResourceStream <Program> ("Template.dzc"))
using (var reader = new StreamReader(stream))
{
doc = XDocument.Parse(reader.ReadToEnd());
}
var collectionNode = doc.Root;
Debug.Assert(collectionNode != null);
collectionNode.SetAttributeValue("Format", imageFormat);
// the <Size> element is the same for all <I> elements
#region <Size Width="800" Height="400" />
var sizeNode = new XElement(SizeNodeName);
sizeNode.SetAttributeValue("Width", originalImageWidth);
sizeNode.SetAttributeValue("Height", originalImageHeight);
#endregion
var itemsNode = collectionNode.XPathSelectElement("dz:Items", namespaceManager);
var mortonNumber = 0;
var maxPostId = 0;
foreach (var postId in postIds)
{
var itemNode =
CreateImageCollectionItemNode(mortonNumber, postId, postFileNameFormat, relativePathToRoot);
itemNode.Add(sizeNode);
itemsNode.Add(itemNode);
mortonNumber++;
maxPostId = Math.Max(maxPostId, postId);
}
// @NextItemId is documented as:
// "Gets the count of items in the collection; however for Deep Zoom
// this does not matter because collections are read-only"
// ...BUT Pivot is very finicky about this one and will consider an
// entire .dzc invalid if this isn't one more than the highest @Id in the .dzc document.
collectionNode.SetAttributeValue("NextItemId", maxPostId + 1);
return(collectionNode);
}
public void Resize_Half()
{
using (var inputStream = AssemblyExtensions.OpenScopedResourceStream <DeepZoomImageTest> ("1200x1500.png"))
using (var sourceBitmap = new Bitmap(inputStream))
using (var targetBitmap = DeepZoomImage.Resize(sourceBitmap, 600, 750))
using (var actualStream = new MemoryStream())
{
targetBitmap.Save(actualStream, ImageFormat.Png);
ProgramTest.AssertStreamsAreEqual <DeepZoomImageTest> ("600x750.png", actualStream);
}
}
/// <summary>
/// Creates a new instance of the <see cref="SourceRepository"/> class.
/// </summary>
public SourceRepository()
{
_revisionTablesByBranchId = new Dictionary <string, DataTable>();
var branchIdsToRevisionRepositories = new Dictionary <string, string>
{
{ "root", "root.xml" },
{ "trunk", "suitability.xml" },
{ "123_DoFtp", "thesis.xml" },
{ "2_DoSftp", "todd.xml" },
{ "436_RefactorInternet", "vendor.xml" },
};
foreach (var pair in branchIdsToRevisionRepositories)
{
var revisions = new DataTable
{
Columns =
{
new DataColumn("ID", typeof(int))
{
Caption = "Revision"
},
{ "Author", typeof(string) },
{ "Date", typeof(DateTime) },
{ "Message", typeof(string) },
},
};
using (var stream = AssemblyExtensions.OpenScopedResourceStream <SourceRepository>(pair.Value))
{
var doc = new XmlDocument();
doc.Load(stream);
var logEntryNodes = doc.SelectNodes("/log/logentry");
if (logEntryNodes == null)
{
continue;
}
foreach (XmlNode logEntryNode in logEntryNodes)
{
var revision = Convert.ToInt32(logEntryNode.Attributes["revision"].Value, 10);
var authorNode = logEntryNode.SelectSingleNode("author");
var author = authorNode == null ? null : authorNode.InnerText;
var date = ParseIso8601(logEntryNode.SelectSingleNode("date").InnerText);
var msg = logEntryNode.SelectSingleNode("msg").InnerText;
revisions.Rows.Add(revision, author, date, msg);
}
}
_revisionTablesByBranchId.Add(pair.Key, revisions);
}
}
internal static void PivotizeTag(Tag tag, IEnumerable <StreamReader> streamReaders, Stream destination, string siteDomain)
{
XDocument doc;
XmlNamespaceManager namespaceManager;
using (var stream = AssemblyExtensions.OpenScopedResourceStream <Program> ("Template.cxml"))
using (var reader = XmlReader.Create(stream, ReaderSettings))
{
doc = XDocument.Load(reader);
namespaceManager = new XmlNamespaceManager(reader.NameTable);
namespaceManager.AddNamespace("c", CollectionNamespace.NamespaceName);
namespaceManager.AddNamespace("p", PivotNamespace.NamespaceName);
}
var collectionNode = doc.Root;
Debug.Assert(collectionNode != null);
collectionNode.SetAttributeValue("Name", "Tagged Questions: {0}".FormatInvariant(tag.Name));
// TODO: do we want to strip hyphens from tag for AdditionalSearchText?
collectionNode.SetAttributeValue(PivotNamespace + "AdditionalSearchText", tag.Name);
var itemsNode = collectionNode.XPathSelectElement("c:Items", namespaceManager);
itemsNode.SetAttributeValue("HrefBase", "http://{0}/questions/".FormatInvariant(siteDomain));
itemsNode.SetAttributeValue("ImgBase", Path.ChangeExtension(tag.Name, ".dzc"));
using (var writer = new CollectionWriter(destination, WriterSettings, futureCw =>
{
futureCw.Flush();
var sw = new StreamWriter(destination);
foreach (var sr in streamReaders)
{
foreach (var line in sr.Lines())
{
#if DEBUG
sw.WriteLine(line);
#else
sw.Write(line);
#endif
}
sr.Close();
}
sw.Flush();
})
)
{
doc.Save(writer);
}
}
public void Slice_Typical()
{
var tiles = new[]
{
new Pair <Rectangle, string>(DeepZoomImage.CreateRectangle(new Point(0, 0), new Point(254, 254)), "0_0"),
new Pair <Rectangle, string>(DeepZoomImage.CreateRectangle(new Point(0, 253), new Point(254, 374)), "0_1"),
new Pair <Rectangle, string>(DeepZoomImage.CreateRectangle(new Point(253, 0), new Point(299, 254)), "1_0"),
new Pair <Rectangle, string>(DeepZoomImage.CreateRectangle(new Point(253, 253), new Point(299, 374)), "1_1"),
};
var streams = new Dictionary <string, MemoryStream>
{
{ "0_0", new MemoryStream() },
{ "0_1", new MemoryStream() },
{ "1_0", new MemoryStream() },
{ "1_1", new MemoryStream() },
};
var settings = new Settings {
PostImageEncoding = ImageFormat.Png,
};
var dzi = new DeepZoomImage(settings);
try
{
using (var inputStream = AssemblyExtensions.OpenScopedResourceStream <DeepZoomImageTest> ("300x375.png"))
using (var sourceBitmap = new Bitmap(inputStream))
{
dzi.Slice(sourceBitmap, tiles, tilename => streams[tilename]);
}
foreach (var keyValuePair in streams)
{
var expectedResourceFileName = keyValuePair.Key + ".png";
var actualStream = keyValuePair.Value;
ProgramTest.AssertStreamsAreEqual <DeepZoomImageTest> (expectedResourceFileName, actualStream);
}
}
finally
{
foreach (var stream in streams.Values)
{
stream.Close();
stream.Dispose();
}
}
}
internal static void CreateRawItems(Settings settings, PostRepository postRepository)
{
var workingPath = Path.GetFullPath(WorkingFolderName);
Directory.CreateDirectory(workingPath);
Page template;
using (var stream = AssemblyExtensions.OpenScopedResourceStream <Program> ("Template.xaml"))
{
template = (Page)XamlReader.Load(stream);
template.Width = settings.ItemImageSize.Width;
template.Height = settings.ItemImageSize.Height;
}
var imageFormat = settings.PostImageEncoding;
var imageExtension = imageFormat.ToString().ToLower();
var posts = postRepository.RetrievePosts();
foreach (var post in posts)
{
var relativeBinnedXmlPath = post.ComputeBinnedPath(".xml", settings.FileNameIdFormat);
var absoluteBinnedXmlPath = Path.Combine(workingPath, relativeBinnedXmlPath);
Directory.CreateDirectory(Path.GetDirectoryName(absoluteBinnedXmlPath));
var element = PivotizePost(post);
using (var outputStream =
new FileStream(absoluteBinnedXmlPath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
using (var writer = new ItemWriter(outputStream, ItemWriterSettings))
{
element.Save(writer);
}
}
var relativeBinnedImagePath = post.ComputeBinnedPath(imageExtension, settings.FileNameIdFormat);
var absoluteBinnedImagePath = Path.Combine(workingPath, relativeBinnedImagePath);
Directory.CreateDirectory(Path.GetDirectoryName(absoluteBinnedImagePath));
using (var outputStream
= new FileStream(absoluteBinnedImagePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
ImagePost(post, template, imageFormat, outputStream);
}
}
}
public void CreateCollectionTile()
{
using (var oneStream = AssemblyExtensions.OpenScopedResourceStream <DeepZoomCollectionTest> ("1.png"))
using (var one = new Bitmap(oneStream))
using (var twoStream = AssemblyExtensions.OpenScopedResourceStream <DeepZoomCollectionTest> ("2.png"))
using (var two = new Bitmap(twoStream))
using (var threeStream = AssemblyExtensions.OpenScopedResourceStream <DeepZoomCollectionTest> ("3.png"))
using (var three = new Bitmap(threeStream))
using (var fourStream = AssemblyExtensions.OpenScopedResourceStream <DeepZoomCollectionTest> ("4.png"))
using (var four = new Bitmap(fourStream))
{
var sourceBitmaps = new[] { one, two, three, four };
using (var actualBitmap = DeepZoomCollection.CreateCollectionTile(sourceBitmaps, 128))
using (var actualStream = new MemoryStream())
{
actualBitmap.Save(actualStream, ImageFormat.Png);
ProgramTest.AssertStreamsAreEqual <DeepZoomCollectionTest> ("1234.png", actualStream);
}
}
}
// TODO: Move to re-usable class library
internal static void AssertStreamsAreEqual <T>(string expectedResourceFileName, MemoryStream actualStream)
{
using (var expectedStream = AssemblyExtensions.OpenScopedResourceStream <T> (expectedResourceFileName))
{
var expectedBytes = expectedStream.EnumerateBytes();
actualStream.Seek(0, SeekOrigin.Begin);
var actualBytes = actualStream.EnumerateBytes();
try
{
EnumerableExtensions.EnumerateSame(expectedBytes, actualBytes);
}
catch (AssertionException)
{
actualStream.Seek(0, SeekOrigin.Begin);
using (var fileStream = expectedResourceFileName.CreateWriteStream())
{
actualStream.WriteTo(fileStream);
}
throw;
}
}
}
/// <summary>
/// Performs the customization.
/// </summary>
protected override void ExecuteTask()
{
if (-1 == _buildNumber)
{
Log(Level.Info, "No customization performed.");
return;
}
#region transform
Log(Level.Verbose, "Loading stylesheet...");
var transform = new XslCompiledTransform();
using (var stream = AssemblyExtensions.OpenScopedResourceStream <CustomizeAssemblyTask>("CustomInfo_cs.xsl"))
{
using (var reader = XmlReader.Create(stream))
{
transform.Load(reader);
}
}
#endregion
#region Version
if (null == Version)
{
if (null == VersionFile)
{
VersionFile = new FileInfo(Path.Combine(BaseDirectory.FullName, "Version.xml"));
}
Log(Level.Verbose, "Loading VersionFile = {0}...", VersionFile.FullName);
using (var stream = VersionFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
var doc = new XmlDocument();
doc.Load(stream);
Version = doc;
}
}
#endregion
#region arguments
var arguments = new XsltArgumentList();
Action <string, object> addParam = (name, value) =>
{
if (value != null)
{
Log(Level.Verbose, "Adding param {0} = {1}", name, value);
arguments.AddParam(name, String.Empty, value);
}
};
addParam("buildNumber", _buildNumber);
addParam("registeredUserDisplayName", _registeredUserDisplayName);
addParam("registeredUserEmailAddress", _registeredUserEmailAddress);
#endregion
foreach (string project in EnumerateProjectNames())
{
Log(Level.Info, "Customizing {0}...", project);
var projectDir = Path.Combine(BaseDirectory.FullName, project);
var outputFile = Path.Combine(projectDir, "Properties/CustomInfo.cs");
if (File.Exists(outputFile))
{
Log(Level.Verbose, "Deleting {0}...", outputFile);
File.Delete(outputFile);
}
Log(Level.Verbose, "Generating {0}...", outputFile);
using (var stream = File.Open(outputFile, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read))
{
transform.Transform(Version, arguments, stream);
}
}
}
