public void ImportBackgroundShareImage(EmguImage newImg, Pixel[] fullImg, Stream mapStr)
{
if (newImg == null || mapStr == null)
{
throw new ArgumentNullException();
}
int width = newImg.Width;
int height = newImg.Height;
int maxColors = this.Format.MaxColors();
// Quantizate image -> get pixels
this.Quantization.Quantizate(newImg);
Pixel[] pixels = this.Quantization.GetPixels(this.PixelEncoding);
if (this.Quantization.Palette.Length > maxColors)
{
throw new FormatException(string.Format("The image has more than {0} colors", maxColors));
}
// Create map
Nscr nscr = new Nscr()
{
TileSize = this.TileSize,
Width = width,
Height = height,
BgMode = this.BgMode,
PaletteMode = PaletteMode.Palette256_1,
Mapping = new MatchMapping(fullImg)
};
nscr.CreateMap(pixels);
nscr.Write(mapStr);
}
public static Ncgr LoadNgcr(string argumentosImg)
{
string[] argSplit = argumentosImg.Split(',');
BinaryReader leitorNclr = new BinaryReader(new MemoryStream(BinaryManager.GetFile(argSplit[1])));
Nclr nclr = new Nclr(leitorNclr, argSplit[1]);
BinaryReader leitorNgcr = new BinaryReader(new MemoryStream(BinaryManager.GetFile(argSplit[0])));
Ncgr ncgr;
if (argumentosImg.Contains(".nscr"))
{
BinaryReader leitorNscr = new BinaryReader(new MemoryStream(BinaryManager.GetFile(argSplit[2])));
Nscr nscr = new Nscr(leitorNscr, argSplit[2]);
ncgr = new Ncgr(leitorNgcr, nclr, nscr, argSplit[0], argSplit[3]);
}
else if (argumentosImg.Contains(".ncer"))
{
BinaryReader leitorNscer = new BinaryReader(new MemoryStream(BinaryManager.GetFile(argSplit[2])));
Ncer ncer = new Ncer(leitorNscer, argSplit[2]);
ncgr = new Ncgr(leitorNgcr, nclr, ncer, argSplit[0], argSplit[3]);
}
else
{
ncgr = new Ncgr(leitorNgcr, nclr, argSplit[0], argSplit[2]);
}
return(ncgr);
}
private static void ImportTestBackground(string mapFile, string imgFile, string palFile)
{
FileStream oldPalStr = new FileStream(palFile, FileMode.Open);
FileStream oldImgStr = new FileStream(imgFile, FileMode.Open);
FileStream oldMapStr = new FileStream(mapFile, FileMode.Open);
MemoryStream newPalStr = new MemoryStream();
MemoryStream newImgStr = new MemoryStream();
MemoryStream newMapStr = new MemoryStream();
Nclr nclr = new Nclr(oldPalStr);
Ncgr ncgr = new Ncgr(oldImgStr);
Nscr nscr = new Nscr(oldMapStr);
EmguImage bmp = nscr.CreateBitmap(ncgr, nclr);
bmp.Save(mapFile + ".png");
BackgroundImporter importer = new BackgroundImporter();
importer.ImportBackground(bmp, newMapStr, newImgStr, newPalStr);
if (!Compare(oldPalStr, newPalStr))
{
string newPalFile = palFile + ".new";
WriteStream(newPalFile, newPalStr);
Console.WriteLine("Palette different... Written to {0}", newPalFile);
}
if (!Compare(oldImgStr, newImgStr))
{
string newImgFile = imgFile + ".new";
WriteStream(newImgFile, newImgStr);
Console.WriteLine("Image different... Written to {0}", newImgFile);
}
if (!Compare(oldMapStr, newMapStr))
{
string newMapFile = mapFile + ".new";
WriteStream(newMapFile, newMapStr);
Console.WriteLine("Map different... Written to {0}", newMapFile);
}
newPalStr.Position = newImgStr.Position = newMapStr.Position = 0;
nclr = new Nclr(newPalStr);
ncgr = new Ncgr(newImgStr);
nscr = new Nscr(newMapStr);
nscr.CreateBitmap(ncgr, nclr).Save(mapFile + "m.png");
oldPalStr.Close();
oldImgStr.Close();
oldMapStr.Close();
newPalStr.Close();
newImgStr.Close();
newMapStr.Close();
}
private static void MapInfo(string mapFile, string imgFile, string palFile, string outputFile)
{
Console.WriteLine("Reading {0} as NCLR palette...", palFile);
Nclr palette = new Nclr(palFile);
Console.WriteLine("Reading {0} as NCGR image...", imgFile);
Ncgr image = new Ncgr(imgFile);
Console.WriteLine("Reading {0} as NSCR map...", mapFile);
Nscr map = new Nscr(mapFile);
Console.WriteLine("\t* Version: {0}", map.NitroData.VersionS);
Console.WriteLine("\t* Height: {0}", map.Height);
Console.WriteLine("\t* Width: {0}", map.Width);
Console.WriteLine("\t* BG Mode: {0}", map.BgMode);
Console.WriteLine("\t* Palette Mode: {0}", map.PaletteMode);
map.CreateBitmap(image, palette).Save(outputFile);
}
public Ncgr(BinaryReader br, Nclr nclr, Nscr nscr, string diretorio, string exportPath) : base(br, diretorio)
{
if (Errors.Count == 0 && nclr.Errors.Count == 0 && nscr.Errors.Count == 0)
{
ArquivoNscr = nscr;
ArquivoNclr = nclr;
SetNgcrProperties(br, exportPath);
CarregarImagemNCGRComNSCR();
ImportarNgcr = new Importar(ImportaNCGRComNscr);
ExportarImagem = new Exportar(ExportarNcgrComOuSemNscr);
}
else
{
AllErrors.AddRange(Errors);
AllErrors.AddRange(nclr.Errors);
AllErrors.AddRange(nscr.Errors);
}
br.Close();
}
public void SetOriginalSettings(Stream mapStr, Stream imgStr, Stream palStr,
bool changePalette = false)
{
// Set original palette settings
if (palStr != null)
{
Nclr nclr = new Nclr(palStr);
this.ExtendedPalette = nclr.Extended;
if (!changePalette)
{
this.Quantization = new FixedPaletteQuantization(nclr.GetPalette(0));
}
}
// Set original image settings if the file is not compressed
if (imgStr != null && imgStr.ReadByte() == 0x52)
{
imgStr.Position -= 1;
Ncgr ncgr = new Ncgr(imgStr);
this.DispCnt = ncgr.RegDispcnt;
this.UnknownChar = ncgr.Unknown;
this.Format = ncgr.Format;
this.IncludeCpos = ncgr.HasCpos;
this.PixelEncoding = ncgr.PixelEncoding;
}
// Set original map settings
if (mapStr != null && mapStr.ReadByte() == 0x52)
{
mapStr.Position -= 1;
Nscr nscr = new Nscr(mapStr);
this.BgMode = nscr.BgMode;
this.PaletteMode = nscr.PaletteMode;
this.TileSize = nscr.TileSize;
}
}
/// <summary>
/// Import a background image creating and writing a NSCR, NCGR and NCLR files to the streams passed.
/// </summary>
/// <param name="imgPath">Image path.</param>
/// <param name="mapStr">Map stream output.</param>
/// <param name="imgStr">Image stream output.</param>
/// <param name="palStr">Pal strream output.</param>
public void ImportBackground(EmguImage newImg, Stream mapStr, Stream imgStr, Stream palStr)
{
if (newImg == null)
{
throw new ArgumentNullException();
}
int width = newImg.Width;
int height = newImg.Height;
int maxColors = this.Format.MaxColors();
Pixel[] pixels;
Color[] palette;
List <int> mapPalette = new List <int>();
bool is16ColFixed = (Format == ColorFormat.Indexed_4bpp) &&
(PaletteMode == PaletteMode.Palette16_16) && (Quantization is FixedPaletteQuantization);
if (!is16ColFixed)
{
// Quantizate image -> get pixels and palette
this.Quantization.Quantizate(newImg);
pixels = this.Quantization.GetPixels(this.PixelEncoding);
palette = this.Quantization.Palette;
if (palette.Length > maxColors)
{
throw new FormatException(string.Format("The image has more than {0} colors", maxColors));
}
}
else
{
Console.Write("(16 Color fixed!) ");
palette = this.Quantization.Palette;
ManyFixedPaletteQuantization quant = new ManyFixedPaletteQuantization(
this.Quantization.Palette.Split(16).ToArray());
List <Pixel> pixelList = new List <Pixel>();
for (int y = 0; y < newImg.Height; y += this.TileSize.Height)
{
for (int x = 0; x < newImg.Width; x += this.TileSize.Width)
{
Rectangle subArea = new Rectangle(x, y, this.TileSize.Width, this.TileSize.Height);
EmguImage subImage = newImg.Copy(subArea);
quant.Quantizate(subImage);
mapPalette.Add(quant.SelectedPalette);
pixelList.AddRange(quant.GetPixels(PixelEncoding.Lineal));
}
}
pixels = pixelList.ToArray();
}
// Create palette format
Nclr nclr = new Nclr()
{
Extended = this.ExtendedPalette
};
nclr.SetData(palette, this.Format);
// Create map from pixels
Nscr nscr = new Nscr()
{
TileSize = this.TileSize,
Width = width,
Height = height,
BgMode = this.BgMode,
PaletteMode = this.PaletteMode
};
if (!is16ColFixed)
{
nscr.PaletteMode = (this.Format == ColorFormat.Indexed_4bpp) ?
PaletteMode.Palette16_16 : PaletteMode.Palette256_1;
pixels = nscr.CreateMap(pixels);
}
else
{
nscr.PaletteMode = PaletteMode.Palette16_16;
pixels = nscr.CreateMap(pixels, mapPalette.ToArray());
}
if (this.PartialImage)
{
// As the image won't expand to all the screen,
// The first tile must be transparent
int tilesizeLength = this.TileSize.Width * this.TileSize.Height;
Pixel[] newPixels = new Pixel[pixels.Length + tilesizeLength];
// New transparent pixels
for (int i = 0; i < tilesizeLength; i++)
{
newPixels[i] = new Pixel(0, 255, true);
}
// Image pixels
Array.Copy(pixels, 0, newPixels, tilesizeLength, pixels.Length);
pixels = newPixels;
// Update map info
MapInfo[] mapInfo = nscr.GetMapInfo();
for (int i = 0; i < mapInfo.Length; i++)
{
mapInfo[i] = new MapInfo(
mapInfo[i].TileIndex + 1,
mapInfo[i].PaletteIndex,
mapInfo[i].FlipX,
mapInfo[i].FlipY);
}
nscr.SetMapInfo(mapInfo);
}
// Create image format
Ncgr ncgr = new Ncgr()
{
RegDispcnt = this.DispCnt,
Unknown = this.UnknownChar
};
ncgr.Width = (pixels.Length > 256) ? 256 : pixels.Length;
ncgr.Height = (int)Math.Ceiling(pixels.Length / (double)ncgr.Width);
if (ncgr.Height % this.TileSize.Height != 0)
{
ncgr.Height += this.TileSize.Height - (ncgr.Height % this.TileSize.Height);
}
ncgr.SetData(pixels, this.PixelEncoding, this.Format, this.TileSize);
// Write data
if (palStr != null)
{
nclr.Write(palStr);
}
if (imgStr != null)
{
ncgr.Write(imgStr);
}
if (mapStr != null)
{
nscr.Write(mapStr);
}
}
