public static async Task WriteCodeFile(this IMatrixProject project, StorageFolder folder, IBuildService buildService)
{
// ***
// *** Get the template from the resource file.
// ***
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, "Reading code template.");
ResourceContext resourceContext = ResourceContext.GetForViewIndependentUse();
ResourceMap resourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("CodeBuilder/Code");
ResourceCandidate resourceValue = resourceMap.GetValue("cpp", resourceContext);
string template = resourceValue.ValueAsString;
// ***
// *** Fill in the template parameters.
// ***
string contents = String.Format(template, project.Name,
project.ColorMatrix.BackgroundColor.R,
project.ColorMatrix.BackgroundColor.G,
project.ColorMatrix.BackgroundColor.B,
project.AccelerometerScaling,
project.Elasticity,
project.SortParticles.ToString().ToLower());
// ***
// *** Write the file.
// ***
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, $"Writing C++ code file '{project.CppFileName()}'.");
StorageFile file = await folder.CreateFileAsync(project.CppFileName(), CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, contents, Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
public async Task <bool> Build(IMatrixProject project, StorageFolder folder)
{
bool returnValue = true;
this.OnBuildEvent(BuildEventArgs.BuildEventType.Information, $"Build started.");
// ***
// *** Get the .cpp code, format it and write the file.
// ***
await project.WriteCodeFile(folder, this);
// ***
// *** Create make file text file.
// ***
string headerCode = await project.CreateHeaderFile(this);
await project.WriteHeaderFile(folder, headerCode, this);
// ***
// *** Create make file text file.
// ***
await project.WriteMakeFile(folder, this);
// ***
// *** Create make file text file.
// ***
await project.WriteInstructionsFile(folder, this);
this.OnBuildEvent(BuildEventArgs.BuildEventType.Information, $"Completed.");
return(returnValue);
}
public static async Task RestoreImageMetaData(this IMatrixProject project, StorageFile file)
{
ImageProperties properties = await file.Properties.GetImagePropertiesAsync();
if (properties.CameraModel.IsHexColor())
{
project.ColorMatrix.BackgroundColor = properties.CameraModel.ToColor();
if (!String.IsNullOrEmpty(properties.Title))
{
project.Name = properties.Title;
}
}
else
{
if (!String.IsNullOrWhiteSpace(properties.CameraModel) && properties.CameraModel.Substring(0, 1) == "{")
{
IMatrixProject projectProperties = JsonConvert.DeserializeObject <MatrixProject>(properties.CameraModel);
project.AccelerometerScaling = projectProperties.AccelerometerScaling;
project.Elasticity = projectProperties.Elasticity;
project.MaskOutputColumns = projectProperties.MaskOutputColumns;
project.Name = projectProperties.Name;
project.PixelOutputColumns = projectProperties.PixelOutputColumns;
project.RandomSandCount = projectProperties.RandomSandCount;
project.SortParticles = projectProperties.SortParticles;
project.UseRandomSand = projectProperties.UseRandomSand;
}
}
}
public static async Task WriteHeaderFile(this IMatrixProject project, StorageFolder folder, string headerCode, IBuildService buildService)
{
// ***
// *** Write the header file (.h)
// ***
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, $"Writing .h code file '{project.HeaderFileName()}'.");
StorageFile hFile = await folder.CreateFileAsync(project.HeaderFileName(), CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(hFile, headerCode, Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
public static string CreateImageCode(this IMatrixProject project)
{
StringBuilder returnValue = new StringBuilder();
returnValue.AppendLine($"#define IMAGE_WIDTH {project.ColorMatrix.Width}");
returnValue.AppendLine($"#define IMAGE_HEIGHT {project.ColorMatrix.Height}");
returnValue.AppendLine();
returnValue.AppendLine("const uint32_t image_color[IMAGE_HEIGHT][IMAGE_WIDTH] =");
returnValue.AppendLine("{");
int i = 0;
for (uint row = 0; row < project.ColorMatrix.Height; row++)
{
for (uint column = 0; column < project.ColorMatrix.Width; column++)
{
ColorItem colorItem = project.ColorMatrix.ColorItems[row, column];
Color color = colorItem;
if (i == 0)
{
returnValue.Append("\t");
}
if (colorItem.ItemType == ColorItem.ColorItemType.Background ||
colorItem.ItemType == ColorItem.ColorItemType.Sand)
{
returnValue.Append("0x00000000");
}
else
{
returnValue.Append($"{color.ToHexInt()}");
}
if (i < ((project.ColorMatrix.Height * project.ColorMatrix.Width) - 1))
{
returnValue.Append(", ");
}
if ((i + 1) % project.PixelOutputColumns == 0)
{
returnValue.AppendLine();
returnValue.Append("\t");
}
i++;
}
}
returnValue.AppendLine();
returnValue.Append("};");
return(returnValue.ToString());
}
protected Task ApplyProjectSettings(IMatrixProject project)
{
this.ProjectName = project.Name;
this.UseRandomSand = project.UseRandomSand;
this.RandomSandCount = (int)project.RandomSandCount;
this.BackgroundColor = project.BackgroundColor;
//project.PixelOutputColumns;
//project.MaskOutputColumns;
return(Task.FromResult(0));
}
public static async Task WriteMakeFile(this IMatrixProject project, StorageFolder folder, IBuildService buildService)
{
StringBuilder contents = new StringBuilder();
contents.AppendLine($"{project.Name}: {project.CppFileName()} {project.HeaderFileName()} $(LIBS)");
contents.AppendLine($"\t$(CXX) $(CXXFLAGS) $< $(LDFLAGS) $(LIBS) -o $@");
contents.AppendLine($"\tstrip $@");
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, $"Writing make file '{project.MakeFileName()}'.");
StorageFile file = await folder.CreateFileAsync(project.MakeFileName(), CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, contents.ToString(), Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
public static async Task SaveProjectMetaData(this IMatrixProject project, StorageFile file)
{
ImageProperties properties = await file.Properties.GetImagePropertiesAsync();
ResourceLoader resLoader = new ResourceLoader();
properties.DateTaken = DateTimeOffset.Now;
properties.CameraManufacturer = resLoader.GetString("AppDisplayName");
properties.Title = project.Name;
properties.CameraModel = JsonConvert.SerializeObject(project);
await properties.SavePropertiesAsync();
}
public static string CreateMaskCode(this IMatrixProject project)
{
StringBuilder returnValue = new StringBuilder();
returnValue.AppendLine("const uint8_t image_mask[IMAGE_HEIGHT][IMAGE_WIDTH] =");
returnValue.AppendLine("{");
int i = 0;
for (uint row = 0; row < project.ColorMatrix.Height; row++)
{
for (uint column = 0; column < project.ColorMatrix.Width; column++)
{
ColorItem colorItem = project.ColorMatrix.ColorItems[row, column];
if (i == 0)
{
returnValue.Append("\t");
}
if (colorItem.ItemType == ColorItem.ColorItemType.Background ||
colorItem.ItemType == ColorItem.ColorItemType.Sand)
{
returnValue.Append($"0");
}
else
{
returnValue.Append($"1");
}
if (i < ((project.ColorMatrix.Height * project.ColorMatrix.Width) - 1))
{
returnValue.Append(", ");
}
if ((i + 1) % project.MaskOutputColumns == 0)
{
returnValue.AppendLine();
returnValue.Append("\t");
}
i++;
}
}
returnValue.AppendLine();
returnValue.Append("};");
return(returnValue.ToString());
}
public static async Task <bool> SaveAsync(this IMatrixProject project, StorageFile file)
{
bool returnValue = false;
// ***
// *** The data is always mapped to BGRA8 pixel format.
// ***
byte[] data = await project.ColorMatrix.CreateImageDataAsync();
await data.CreateImageAsync(project.ColorMatrix.Height, project.ColorMatrix.Width, file);
await project.SaveProjectMetaData(file);
returnValue = true;
return(returnValue);
}
public static async Task WriteInstructionsFile(this IMatrixProject project, StorageFolder folder, IBuildService buildService)
{
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, "Reading instructions template.");
ResourceContext resourceContext = ResourceContext.GetForViewIndependentUse();
ResourceMap resourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("CodeBuilder/Code");
ResourceCandidate resourceValue = resourceMap.GetValue("instructions", resourceContext);
string template = resourceValue.ValueAsString;
string contents = String.Format(template, project.CppFileName(),
project.HeaderFileName(),
project.MakeFileName(),
project.Name);
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, $"Writing instructions file '{project.InstructionsFileName()}'.");
StorageFile file = await folder.CreateFileAsync(project.InstructionsFileName(), CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, contents, Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
public static Task <string> CreateHeaderFile(this IMatrixProject project, IBuildService buildService)
{
StringBuilder returnValue = new StringBuilder();
// ***
// *** Generate the image definition.
// ***
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, "Generating image code.");
string imageCode = project.CreateImageCode();
// ***
// *** Generate the mask definition.
// ***
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, "Generating mask code.");
string maskCode = project.CreateMaskCode();
// ***
// *** Generate the sand grain definition.
// ***
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, "Generating grain code.");
(bool result, string grainCode) = project.CreateGrainCode();
if (!result)
{
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Warning, "No sand grains have been defined.");
}
buildService.FireBuildEvent(BuildEventArgs.BuildEventType.Information, "Generating header file code.");
// ***
// *** Generate the header file (.h)
// ***
returnValue.AppendLine(grainCode);
returnValue.AppendLine();
returnValue.AppendLine(imageCode);
returnValue.AppendLine();
returnValue.AppendLine(maskCode);
return(Task.FromResult(returnValue.ToString()));
}
public async void OnLoadCommand()
{
try
{
FileOpenPicker openPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
openPicker.FileTypeFilter.Add(".bmp");
openPicker.FileTypeFilter.Add(".tif");
openPicker.FileTypeFilter.Add(".tiff");
StorageFile file = await openPicker.PickSingleFileAsync();
if (file != null)
{
// ***
// *** Get a copy of the current color matrix.
// ***
IColorMatrix oldColorMatrix = await this.ColorMatrix.CloneAsync();
IMatrixProject oldProject = this.CurrentProject;
// ***
// *** Read the image/project from an image file.
// ***
IMatrixProject project = await file.LoadFromImageAsync(ImageEditorViewModel.DefaultColumnCount, ImageEditorViewModel.DefaultColumnCount);
await this.ColorMatrix.CopyFrom(project.ColorMatrix);
await this.ApplyProjectSettings(project);
// ***
// *** Set up the undo task.
// ***
async Task undoAction()
{
await this.ColorMatrix.CopyFrom(oldColorMatrix); await this.ApplyProjectSettings(oldProject);
}
async Task redoAction()
{
await this.ColorMatrix.CopyFrom(project.ColorMatrix); await this.ApplyProjectSettings(project);
}
await this.UndoService.AddUndoTask(undoAction, redoAction, $"Load File [{file.Name}]");
}
}
catch (BadImageFormatException)
{
MessageDialog dialog = new MessageDialog("ExceptionImageTooLarge".GetLocalized(), "Exception".GetLocalized());
await dialog.ShowAsync();
}
catch (Exception ex)
{
MessageDialog dialog = new MessageDialog(ex.Message, "Exception".GetLocalized());
await dialog.ShowAsync();
}
}
public static (bool, string) CreateGrainCode(this IMatrixProject project)
{
(bool result, string text) = (false, String.Empty);
StringBuilder code = new StringBuilder();
uint grainCount = 0;
if (!project.UseRandomSand)
{
grainCount = project.ColorMatrix.GetPixelCount(ColorItem.ColorItemType.Sand);
}
else
{
grainCount = project.RandomSandCount;
}
code.AppendLine("// ***");
code.AppendLine("// *** Define the number of grains of sand on matrix.");
code.AppendLine("// ***");
code.AppendLine($"#define NUM_GRAINS {grainCount}");
code.AppendLine();
code.AppendLine("// ***");
code.AppendLine("// *** Defines the initial position and color");
code.AppendLine("// *** of each grain (x, y, color).");
code.AppendLine("// ***");
code.AppendLine("const uint32_t grains[NUM_GRAINS][3] =");
code.AppendLine("{");
if (!project.UseRandomSand)
{
uint index = 0;
for (uint row = 0; row < project.ColorMatrix.Height; row++)
{
for (uint column = 0; column < project.ColorMatrix.Width; column++)
{
ColorItem colorItem = project.ColorMatrix.ColorItems[row, column];
if (colorItem.ItemType == ColorItem.ColorItemType.Sand)
{
Color color = colorItem;
code.Append($"\t{column.ToString().PadLeft(2, ' ')}, {row.ToString().PadLeft(2, ' ')}, {color.ToHexInt()}");
index++;
if (index < grainCount)
{
code.AppendLine(",");
}
}
}
}
code.AppendLine();
}
code.AppendLine("};");
code.AppendLine();
code.AppendLine("// ***");
code.AppendLine("// *** Determines if the initial sand");
code.AppendLine("// *** position(s) are randomized.");
code.AppendLine("// ***");
if (project.UseRandomSand)
{
code.Append("#define USE_RANDOM_SAND 1");
}
else
{
code.Append("#define USE_RANDOM_SAND 0");
}
result = project.UseRandomSand ? true : (grainCount > 0);
return(result, code.ToString());
}
public static string CppFileName(this IMatrixProject project) => $"{project.Name}-image.cpp";
public static string InstructionsFileName(this IMatrixProject project) => $"{project.Name}-instructions.txt";
public static string MakeFileName(this IMatrixProject project) => $"{project.Name}-make.txt";
public static string HeaderFileName(this IMatrixProject project) => $"{project.Name}-image.h";
