public async Task AppendRecordsAsync(string orderNumber, RawDataContainer container, CancellationToken cancellationToken)
{
using var connection = await _factory.CreateConnectionAsync(cancellationToken);
using var transaction = connection.BeginTransaction(IsolationLevel.Serializable);
try
{
if (container.HasSnapshot())
{
await connection.ExecuteAsync(
new CommandDefinition(
EventRepositoryQueries.InsertSnapshot,
new { orderNumber, version = container.RawSnapshot.LastVersion, data = container.RawSnapshot.Raw },
transaction,
cancellationToken : cancellationToken));
}
while (container.RawEvents.TryDequeue(out var data))
{
await connection.ExecuteAsync(
new CommandDefinition(
EventRepositoryQueries.Insert,
new { orderNumber, version = data.Version, type = data.Type, data = data.Data },
transaction,
cancellationToken : cancellationToken));
}
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
_logger.LogError(e, "Event saving error");
throw;
}
}
/// <summary>
/// Extracts additional values to rating calculation from <see cref="RawDataContainer" />.
/// </summary>
/// <param name="rawDataContainer">
/// The object which contains values to normalize properties.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="rawDataContainer" /> is <c>null</c> .
/// </exception>
/// <exception cref="ArgumentException">
/// Popularity characteristics do not contains in <paramref name="rawDataContainer" />.
/// </exception>
public void PrepareCalculation(RawDataContainer rawDataContainer)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
_basicAppraisal.PrepareCalculation(rawDataContainer);
_popularityMMD = rawDataContainer.GetParameter(nameof(TmdbMovieInfo.Popularity));
}
/// <summary>
/// Makes prior analysis through normalizers and calculates ratings based on average vote
/// and vote count.
/// </summary>
/// <param name="rawDataContainer">Entities to appraise with additional parameters.</param>
/// <param name="outputResults">Flag to define need to output.</param>
/// <returns>Collection of result object (data object with rating).</returns>
/// <remarks>
/// Entities collection must be unique because rating calculation errors can occur in such
/// situations.
/// </remarks>
public virtual ResultList GetRatings(RawDataContainer rawDataContainer, bool outputResults)
{
CheckRatingId();
var ratings = new ResultList();
IReadOnlyList <BasicInfo> rawData = rawDataContainer.GetData();
if (rawData.IsNullOrEmpty())
{
return(ratings);
}
MinMaxDenominator voteCountMMD = rawDataContainer.GetParameter("VoteCount");
MinMaxDenominator voteAverageMMD = rawDataContainer.GetParameter("VoteAverage");
foreach (BasicInfo entityInfo in rawData)
{
double ratingValue = CalculateRating(entityInfo, voteCountMMD, voteAverageMMD);
var resultInfo = new ResultInfo(entityInfo.ThingId, ratingValue, RatingId);
ratings.Add(resultInfo);
if (outputResults)
{
GlobalMessageHandler.OutputMessage(resultInfo.ToString());
}
}
ratings.Sort((x, y) => y.RatingValue.CompareTo(x.RatingValue));
return(ratings);
}
/// <summary>
/// Extracts additional values to rating calculation from <see cref="RawDataContainer" />.
/// </summary>
/// <param name="rawDataContainer">
/// The object which contains values to normalize properties.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="rawDataContainer" /> is <c>null</c> .
/// </exception>
/// <exception cref="ArgumentException">
/// Popularity characteristics do not contains in <paramref name="rawDataContainer" />.
/// </exception>
public void PrepareCalculation(RawDataContainer rawDataContainer)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
_basicAppraisal.PrepareCalculation(rawDataContainer);
_priceMMD = rawDataContainer.GetParameter(nameof(SteamGameInfo.Price));
}
public void CallGetRatingsWithConteinerWithThreeItems()
{
IAppraiser appraiser = TestAppraisersCreator.CreateBasicAppraiser();
Guid ratingId = Guid.NewGuid();
appraiser.RatingId = ratingId;
var item1 = new BasicInfo(
thingId: 1, title: "Title-1", voteCount: 11, voteAverage: 9.7
);
var item2 = new BasicInfo(
thingId: 2, title: "Title-2", voteCount: 12, voteAverage: 9.8
);
var item3 = new BasicInfo(
thingId: 3, title: "Title-3", voteCount: 13, voteAverage: 9.9
);
RawDataContainer rawDataContainer =
TestDataCreator.CreateRawDataContainerWithBasicInfo(item1, item2, item3);
IReadOnlyList <ResultInfo> actualValue = appraiser.GetRatings(
rawDataContainer, outputResults: false
);
IReadOnlyList <ResultInfo> expectedValue =
TestDataCreator.CreateExpectedValueForBasicInfo(
ratingId, rawDataContainer, item1, item2, item3
);
Assert.NotNull(actualValue);
Assert.NotEmpty(actualValue);
Assert.All(expectedValue, resultInfo => actualValue.Contains(resultInfo));
}
public void CallGetRatingsWithConteinerWithOneItem()
{
IAppraiser appraiser = TestAppraisersCreator.CreateBasicAppraiser();
Guid ratingId = Guid.NewGuid();
appraiser.RatingId = ratingId;
var item = new BasicInfo(
thingId: 1, title: "Title", voteCount: 10, voteAverage: 9.9
);
RawDataContainer rawDataContainer =
TestDataCreator.CreateRawDataContainerWithBasicInfo(item);
IReadOnlyList <ResultInfo> actualValue = appraiser.GetRatings(
rawDataContainer, outputResults: false
);
IReadOnlyList <ResultInfo> expectedValue =
TestDataCreator.CreateExpectedValueForBasicInfo(
ratingId, rawDataContainer, item
);
Assert.NotNull(actualValue);
Assert.NotEmpty(actualValue);
Assert.Single(actualValue);
Assert.Equal(expectedValue.Single(), actualValue.Single());
}
public void CallGetRatingsWithConteinerWithRandomData(int itemsCount)
{
IAppraiser appraiser = TestAppraisersCreator.CreateBasicAppraiser();
Guid ratingId = Guid.NewGuid();
appraiser.RatingId = ratingId;
IReadOnlyList <BasicInfo> items =
TestDataCreator.CreateBasicInfoListRandomly(itemsCount);
RawDataContainer rawDataContainer =
TestDataCreator.CreateRawDataContainerWithBasicInfo(items);
IReadOnlyList <ResultInfo> actualValue = appraiser.GetRatings(
rawDataContainer, outputResults: false
);
IReadOnlyList <ResultInfo> expectedValue =
TestDataCreator.CreateExpectedValueForBasicInfo(
ratingId, rawDataContainer, items
);
Assert.NotNull(actualValue);
Assert.NotEmpty(actualValue);
Assert.All(expectedValue, resultInfo => actualValue.Contains(resultInfo));
}
/// <summary>
/// Extracts additional values to rating calculation from <see cref="RawDataContainer" />.
/// </summary>
/// <param name="rawDataContainer">
/// The object which contains values to normalize properties.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="rawDataContainer" /> is <c>null</c> .
/// </exception>
/// <exception cref="ArgumentException">
/// Popularity characteristics do not contains in <paramref name="rawDataContainer" />.
/// </exception>
public void PrepareCalculation(RawDataContainer rawDataContainer)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
_basicAppraisal.PrepareCalculation(rawDataContainer);
_metascoreMMD = rawDataContainer.GetParameter(nameof(OmdbMovieInfo.Metascore));
}
/// <summary>
/// Extracts additional values to rating calculation from <see cref="RawDataContainer" />.
/// </summary>
/// <param name="rawDataContainer">
/// The object which contains values to normalize properties.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="rawDataContainer" /> is <c>null</c> .
/// </exception>
/// <exception cref="ArgumentException">
/// Vote count characteristics do not contains in <paramref name="rawDataContainer" />. -or-
/// Vote average characteristics do not contains in <paramref name="rawDataContainer" />.
/// </exception>
public void PrepareCalculation(RawDataContainer rawDataContainer)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
_voteCountMMD = rawDataContainer.GetParameter(nameof(BasicInfo.VoteCount));
_voteAverageMMD = rawDataContainer.GetParameter(nameof(BasicInfo.VoteAverage));
}
/// <summary>
/// The read meta from map.
/// </summary>
/// <param name="tagIndex">The tagIndex.</param>
/// <param name="dontreadraw">The dontreadraw.</param>
/// <remarks></remarks>
public void ReadMetaFromMap(int tagIndex, bool dontReadRaw)
{
// set meta properties
this.Map = Map;
this.TagIndex = tagIndex;
this.type = Map.MetaInfo.TagType[tagIndex];
this.name = Map.FileNames.Name[tagIndex];
this.offset = Map.MetaInfo.Offset[tagIndex];
this.size = Map.MetaInfo.Size[tagIndex];
this.ident = Map.MetaInfo.Ident[tagIndex];
string temps = this.offset.ToString("X");
char[] tempc = temps.ToCharArray();
int xxx = tempc.Length;
this.padding = tempc[xxx - 1];
// THIS = Currently Selected Tag
// Find current Tag Meta and read into memory stream (MS)
this.MS = new MemoryStream(this.size);
Map.BR.BaseStream.Position = this.offset;
this.MS.Write(Map.BR.ReadBytes(this.size), 0, this.size);
// Checks if type has raw data
this.rawType = Map.Functions.ForMeta.CheckForRaw(this.type);
if (dontReadRaw == false)
{
if (rawType != RawDataContainerType.Empty)
{
this.raw = Map.Functions.ForMeta.ReadRaw(this.TagIndex, dontReadRaw);
}
}
if (this.type == "sbsp")
{
int h = Map.BSP.FindBSPNumberByBSPIdent(this.ident);
this.magic = Map.BSP.sbsp[h].magic;
}
else if (this.type == "ltmp")
{
int h = Map.BSP.FindBSPNumberByLightMapIdent(this.ident);
this.magic = Map.BSP.sbsp[h].magic;
}
else
{
// Not "sbsp" or "ltmp"
// For Halo 1 or Halo CE
if (Map.HaloVersion == HaloVersionEnum.HaloCE || Map.HaloVersion == HaloVersionEnum.Halo1)
{
this.magic = Map.PrimaryMagic;
}
else
{
// For Halo 2
this.magic = Map.SecondaryMagic;
}
}
}
internal static IReadOnlyList <ResultInfo> CreateExpectedValueForBasicInfo(Guid ratingId,
RawDataContainer rawDataContainer, params BasicInfo[] items)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
items.ThrowIfNull(nameof(items));
return(CreateExpectedValueForBasicInfo(ratingId, rawDataContainer,
items.AsEnumerable()));
}
public void SetSample_SetGetCheck()
{
var container = new RawDataContainer <double>(5);
uint index = 0;
double value = 0.5;
container.SetSample(index, value);
Assert.That(container.GetSample(index), Is.EqualTo(value));
}
/// <summary>
/// The read raw.
/// </summary>
/// <param name="tagIndex">Index of the tag.</param>
/// <param name="dontreadraw">The dontreadraw.</param>
/// <returns></returns>
/// <remarks></remarks>
public RawDataContainer ReadRaw(int tagIndex, bool dontreadraw)
{
RawDataContainer tempcontainer = new RawDataContainer();
switch (CheckForRaw(map.MetaInfo.TagType[tagIndex]))
{
case RawDataContainerType.PRTM:
tempcontainer = new PRTM();
break;
case RawDataContainerType.DECR:
tempcontainer = new DECR();
break;
case RawDataContainerType.Animation:
tempcontainer = new Animation();
break;
case RawDataContainerType.Model:
tempcontainer = new Model();
break;
case RawDataContainerType.Bitmap:
tempcontainer = new BitmapRaw();
break;
case RawDataContainerType.BSP:
tempcontainer = new BSPRaw();
break;
case RawDataContainerType.Weather:
tempcontainer = new Weather();
break;
case RawDataContainerType.Sound:
tempcontainer = new Sound();
break;
case RawDataContainerType.CoconutsModel:
tempcontainer = new UghRawContainer();
break;
case RawDataContainerType.LightMap:
tempcontainer = new LightmapRaw();
break;
default:
break;
}
tempcontainer.Read(tagIndex, map, dontreadraw);
return(tempcontainer);
}
private RawDataContainer AddAdditionalParameters(IReadOnlyList <BasicInfo> data)
{
var container = new RawDataContainer(data);
switch (data[0])
{
case TmdbMovieInfo _:
{
if (_repositories.TryGetValue(typeof(TmdbMovieInfo),
out IDataRepository repository))
{
container.AddParameter(
nameof(TmdbMovieInfo.VoteCount),
GetAdditionalInfoInt32(repository, "vote_count")
);
container.AddParameter(
nameof(TmdbMovieInfo.VoteAverage),
GetAdditionalInfoDouble(repository, "vote_average")
);
container.AddParameter(
nameof(TmdbMovieInfo.Popularity),
GetAdditionalInfoDouble(repository, "popularity")
);
}
break;
}
case BasicInfo _:
{
if (_repositories.TryGetValue(typeof(BasicInfo),
out IDataRepository repository))
{
container.AddParameter(
nameof(BasicInfo.VoteCount),
GetAdditionalInfoInt32(repository, "vote_count")
);
container.AddParameter(
nameof(BasicInfo.VoteAverage),
GetAdditionalInfoDouble(repository, "vote_average")
);
}
break;
}
default:
{
_logger.Warn($"Unregornized data type: {data[0].GetType().FullName}");
break;
}
}
return(container);
}
static void Main(string[] args)
{
ResampledDataContainer test = new ResampledDataContainer("datasets");
RawDataContainer test2 = new RawDataContainer("datasets");
//var task = test.ConvertToCsv("testnewrouteur", @"../../test.csv");
var task = test.ConvertAllCollectionsToCsv(@"../../csv_files/");
//var task = test2.ConvertToCsv("testdemerde1_raw", @"../../test");
//var task = test2.ConvertAllCollectionsToCsv(@"../../csv_rawfiles/");
task.Wait();
}
public void GetRatingsThrowsExceptionBecauseOfRatingIdIsUnspecified()
{
IAppraiser appraiser = TestAppraisersCreator.CreateBasicAppraiser();
RawDataContainer rawDataContainer =
TestDataCreator.CreateRawDataContainerWithBasicInfo();
Assert.Throws <InvalidOperationException>(
() => appraiser.GetRatings(rawDataContainer, outputResults: false)
);
Assert.Throws <InvalidOperationException>(
() => appraiser.GetRatings(rawDataContainer, outputResults: true)
);
}
/// <summary>
/// Makes prior analysis through prepare stage for strategy and then uses it to calculate
/// ratings.
/// </summary>
/// <param name="rawDataContainer">
/// The entities to appraise with additional parameters.
/// </param>
/// <param name="outputResults">The flag to define need to output.</param>
/// <returns>Collection of result object (data object with rating).</returns>
/// <remarks>
/// Entities collection must be unique because rating calculation errors can occur in such
/// situations.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="rawDataContainer" /> is <c>null</c>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="rawDataContainer" /> contains instances of invalid type for this
/// appraiser.
/// </exception>
public IReadOnlyList <ResultInfo> GetRatings(RawDataContainer rawDataContainer,
bool outputResults)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
CheckRatingId();
var ratings = new List <ResultInfo>();
IReadOnlyList <BasicInfo> rawData = rawDataContainer.RawData;
if (!rawData.Any())
{
return(ratings);
}
// Check if list have proper type.
IReadOnlyList <T> converted = rawData.Select(e =>
{
if (!(e is T result))
{
throw new ArgumentException(
$"Element \"{e.Title}\" (ID = {e.ThingId.ToString()}) type " +
$"\"{e.GetType().FullName}\" is invalid for appraiser with type " +
$"\"{TypeId.FullName}\"."
);
}
return(result);
}).ToList();
_appraisal.PrepareCalculation(rawDataContainer);
foreach (T entityInfo in converted)
{
double ratingValue = _appraisal.CalculateRating(entityInfo);
var resultInfo = new ResultInfo(entityInfo.ThingId, ratingValue, RatingId);
ratings.Add(resultInfo);
if (outputResults)
{
GlobalMessageHandler.OutputMessage($"Appraised {resultInfo} by {Tag}.");
}
}
ratings.Sort((x, y) => y.RatingValue.CompareTo(x.RatingValue));
return(ratings);
}
/// <summary>
/// The split with ifp.
/// </summary>
/// <param name="ifp">The ifp.</param>
/// <param name="meta">The meta.</param>
/// <param name="map">The map.</param>
/// <remarks></remarks>
public void SplitWithIFP(ref IFPIO ifp, ref Meta meta, Map map)
{
this.type = meta.type;
this.TagIndex = meta.TagIndex;
this.name = meta.name;
this.offset = meta.offset;
this.magic = meta.magic;
this.raw = meta.raw;
this.rawtype = meta.rawType;
map.OpenMap(MapTypes.Internal);
if (ifp.items != null)
{
map.BR.BaseStream.Position = meta.offset;
Header = new SplitReflexive();
Header.offset = 0;
Header.Chunks = new List <SplitReflexive>();
Header.translation = 0;
// Header.MS = new MemoryStream(ifp.headerSize);
// Header.MS.Write(map.BR.ReadBytes(ifp.headerSize), 0, ifp.headerSize);
Header.chunksize = ifp.headerSize;
Header.chunkcount = 1;
Header.splitReflexiveType = SplitReflexive.SplitReflexiveType.Container;
Header.realtranslation = meta.offset;
if (meta.type == "sbsp")
{
int p = map.BSP.FindBSPNumberByBSPIdent(meta.ident);
CycleElements(
ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.BSP.sbsp[p].magic);
}
else if (meta.type == "ltmp")
{
int p = map.BSP.FindBSPNumberByLightMapIdent(meta.ident);
CycleElements(
ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.BSP.sbsp[p].magic);
}
else
{
// not "sbsp" or "ltmp"
CycleElements(ref Header, ifp.items, ref meta, meta.offset, map, meta.TagIndex, map.SecondaryMagic);
}
}
map.CloseMap();
}
/// <inheritdoc />
/// <remarks>
/// Considers popularity value in addition to average vote and vote count.
/// </remarks>
/// <exception cref="ArgumentException">
/// <paramref name="rawDataContainer" /> contains instances of invalid type for this
/// appraiser.
/// </exception>
public override ResultList GetRatings(RawDataContainer rawDataContainer, bool outputResults)
{
CheckRatingId();
var ratings = new ResultList();
IReadOnlyList <BasicInfo> rawData = rawDataContainer.GetData();
if (rawData.IsNullOrEmpty())
{
return(ratings);
}
// Check if list have proper type.
if (!rawData.All(e => e is TmdbMovieInfo))
{
throw new ArgumentException(
$"Element type is invalid for appraiser with type {TypeId.FullName}"
);
}
MinMaxDenominator voteCountMMD = rawDataContainer.GetParameter("VoteCount");
MinMaxDenominator voteAverageMMD = rawDataContainer.GetParameter("VoteAverage");
MinMaxDenominator popularityMMD = rawDataContainer.GetParameter("Popularity");
var converted = rawData.Select(e => (TmdbMovieInfo)e);
foreach (TmdbMovieInfo entityInfo in converted)
{
double ratingValue = CalculateRating(entityInfo, voteCountMMD, voteAverageMMD,
popularityMMD);
var resultInfo = new ResultInfo(entityInfo.ThingId, ratingValue, RatingId);
ratings.Add(resultInfo);
if (outputResults)
{
GlobalMessageHandler.OutputMessage($"Appraised {resultInfo} by {Tag}");
}
}
ratings.Sort((x, y) => y.RatingValue.CompareTo(x.RatingValue));
return(ratings);
}
public void CallGetRatingsWithEmptyConteiner()
{
IAppraiser appraiser = TestAppraisersCreator.CreateBasicAppraiser();
Guid ratingId = Guid.NewGuid();
appraiser.RatingId = ratingId;
RawDataContainer rawDataContainer =
TestDataCreator.CreateRawDataContainerWithBasicInfo();
IReadOnlyList <ResultInfo> actualValue = appraiser.GetRatings(
rawDataContainer, outputResults: false
);
IReadOnlyList <ResultInfo> expectedValue = new List <ResultInfo>();
Assert.NotNull(actualValue);
Assert.Empty(actualValue);
Assert.Equal(expectedValue, actualValue);
}
internal static IReadOnlyList <ResultInfo> CreateExpectedValueForBasicInfo(Guid ratingId,
RawDataContainer rawDataContainer, IEnumerable <BasicInfo> items)
{
rawDataContainer.ThrowIfNull(nameof(rawDataContainer));
items.ThrowIfNull(nameof(items));
var appraisal = new BasicAppraisal();
appraisal.PrepareCalculation(rawDataContainer);
var expectedValue = new List <ResultInfo>();
foreach (BasicInfo item in items)
{
double expectedRating = appraisal.CalculateRating(item);
var expectedItem = new ResultInfo(item.ThingId, expectedRating, ratingId);
expectedValue.Add(expectedItem);
}
return(expectedValue);
}
/// <summary>
/// Calculates rating which depends on final and initial price.
/// </summary>
/// <exception cref="ArgumentException">
/// <paramref name="rawDataContainer" /> contains instances of invalid type for this
/// appraiser.
/// </exception>
public override ResultList GetRatings(RawDataContainer rawDataContainer, bool outputResults)
{
CheckRatingId();
var ratings = new ResultList();
IReadOnlyList <BasicInfo> rawData = rawDataContainer.GetData();
if (rawData.IsNullOrEmpty())
{
return(ratings);
}
// Check if list have proper type.
if (!rawData.All(e => e is SteamGameInfo))
{
throw new ArgumentException(
$"Element type is invalid for appraiser with type {TypeId.FullName}"
);
}
var converted = rawData.Select(e => (SteamGameInfo)e);
foreach (SteamGameInfo entityInfo in converted)
{
double ratingValue = decimal.ToDouble(entityInfo.Price) - entityInfo.VoteAverage;
var resultInfo = new ResultInfo(entityInfo.ThingId, ratingValue, RatingId);
ratings.Add(resultInfo);
if (outputResults)
{
GlobalMessageHandler.OutputMessage($"Appraised {resultInfo} by {Tag}");
}
}
ratings.Sort((x, y) => y.RatingValue.CompareTo(x.RatingValue));
return(ratings);
}
internal static RawDataContainer CreateRawDataContainerWithBasicInfo(
IEnumerable <BasicInfo> items)
{
items.ThrowIfNull(nameof(items));
var container = new RawDataContainer(new List <BasicInfo>(items));
if (!container.RawData.Any())
{
return(container);
}
container.AddParameter(
nameof(BasicInfo.VoteCount),
MinMaxDenominator.CreateForCollection(container.RawData, basic => basic.VoteCount)
);
container.AddParameter(
nameof(BasicInfo.VoteAverage),
MinMaxDenominator.CreateForCollection(container.RawData, basic => basic.VoteAverage)
);
return(container);
}
/// <summary> /// Load an image from a memory buffer /// </summary> /// <param name="data"> /// data the image data /// </param> /// <param name="result"> /// the texture to use for storing the image data /// </param> /// <returns> /// result on success or null if the load failed /// </returns> public abstract Texture Load(RawDataContainer data, Texture result);
public void Length_SetGetCheck()
{
var container = new RawDataContainer <double>(5);
Assert.That(container.Length, Is.EqualTo(5));
}
/// <summary>
/// No exctraction will be perfomed because this appraisal no needed in such preparation.
/// </summary>
public void PrepareCalculation(RawDataContainer rawDataContainer)
{
// Nothing to do.
}
public override void LoadFromFile(string filename, string resourceGroup)
{
// Note from PDT:
// There is somewhat tight coupling here between OpenGLTexture and the
// ImageCodec classes - we have intimate knowledge of how they are
// implemented and that knowledge is relied upon in an unhealthy way; this
// should be addressed at some stage.
// load file to memory via resource provider
var texFile = new RawDataContainer();
Base.System.GetSingleton().GetResourceProvider()
.LoadRawDataContainer(filename, texFile, resourceGroup);
//// get and check existence of CEGUI::System (needed to access ImageCodec)
//System* sys = System::getSingletonPtr();
//if (!sys)
// CEGUI_THROW(RendererException(
// "CEGUI::System object has not been created: "
// "unable to access ImageCodec."));
//Texture* res = sys->getImageCodec().load(texFile, this);
using (var ms = new MemoryStream())
{
texFile.Stream().CopyTo(ms);
var bytes = ms.ToArray();
var result = StbImageSharp.ImageResult.FromMemory(bytes, StbImageSharp.ColorComponents.RedGreenBlueAlpha);
var width = result.Width;
var height = result.Height;
var rawBuf = result.Data;
//var img = FreeImageAPI.FreeImage.LoadFromStream(texFile.Stream());
//var newImg = FreeImageAPI.FreeImage.ConvertTo32Bits(img);
//FreeImageAPI.FreeImage.UnloadEx(ref img);
//var pitch = (int) FreeImageAPI.FreeImage.GetPitch(newImg);
//var width = (int) FreeImageAPI.FreeImage.GetWidth(newImg);
//var height = (int) FreeImageAPI.FreeImage.GetHeight(newImg);
//var redMask = FreeImageAPI.FreeImage.GetRedMask(newImg);
//var greenMask = FreeImageAPI.FreeImage.GetGreenMask(newImg);
//var blueMask = FreeImageAPI.FreeImage.GetBlueMask(newImg);
//var rawBuf = new byte[width*height << 2];
//FreeImageAPI.FreeImage.ConvertToRawBits(rawBuf, newImg, pitch, 32, redMask, greenMask, blueMask, true);
//FreeImageAPI.FreeImage.UnloadEx(ref newImg);
//if (FreeImageAPI.FreeImage.IsLittleEndian())
//{
// var offset = 0;
// for (uint i = 0; i < height; ++i)
// {
// for (uint j = 0; j < width; ++j)
// {
// var b = rawBuf[offset + 2];
// rawBuf[offset + 2] = rawBuf[offset + 0];
// rawBuf[offset + 0] = b;
// offset += 4;
// }
// }
//}
LoadFromMemory(rawBuf, new Sizef(width, height), PixelFormat.RGBA);
}
// unload file data buffer
Base.System.GetSingleton().GetResourceProvider().UnloadRawDataContainer(texFile);
//if (!res)
// // It's an error
// CEGUI_THROW(RendererException(
// sys->getImageCodec().getIdentifierString() +
// " failed to load image '" + filename + "'."));
}
/// <summary>
/// Load meta from an XML file.
/// </summary>
/// <param name="inputFileName">The XML file name.</param>
/// <remarks></remarks>
public void LoadMetaFromFile(string inputFileName)
{
// write memorysteam of meta to file
FileStream FS = new FileStream(inputFileName, FileMode.Open);
BinaryReader BR = new BinaryReader(FS);
this.size = (int)FS.Length;
this.MS = new MemoryStream(this.size);
BR.BaseStream.Position = 0;
this.MS.Write(BR.ReadBytes(this.size), 0, this.size);
BR.Close();
FS.Close();
// write idents,strings,reflexives
XmlTextReader xtr = new XmlTextReader(inputFileName + ".xml");
xtr.WhitespaceHandling = WhitespaceHandling.None;
while (xtr.Read())
{
// MessageBox.Show(xtr.Name);
switch (xtr.NodeType)
{
case XmlNodeType.Element:
if (xtr.Name == "Meta")
{
this.type = xtr.GetAttribute("TagType");
this.name = xtr.GetAttribute("TagName");
this.parsed = xtr.GetAttribute("Parsed") == "True" ? true : false;
this.size = Convert.ToInt32(xtr.GetAttribute("Size"));
this.magic = Convert.ToInt32(xtr.GetAttribute("Magic"));
this.padding = Convert.ToChar(xtr.GetAttribute("Padding"));
this.offset = Convert.ToInt32(xtr.GetAttribute("Offset"));
}
else if (xtr.Name == "Reflexive")
{
Reflexive r = new Reflexive();
r.description = xtr.GetAttribute("Description");
r.offset = Convert.ToInt32(xtr.GetAttribute("Offset"));
r.chunkcount = Convert.ToInt32(xtr.GetAttribute("ChunkCount"));
r.chunksize = Convert.ToInt32(xtr.GetAttribute("ChunkSize"));
r.translation = Convert.ToInt32(xtr.GetAttribute("Translation"));
r.pointstotagtype = xtr.GetAttribute("PointsToTagType");
r.pointstotagname = xtr.GetAttribute("PointsToTagName");
r.pointstoTagIndex = Map.Functions.ForMeta.FindByNameAndTagType(
r.pointstotagtype, r.pointstotagname);
r.intagtype = xtr.GetAttribute("TagType");
r.intagname = xtr.GetAttribute("TagName");
r.intag = Map.Functions.ForMeta.FindByNameAndTagType(r.intagtype, r.intagname);
this.items.Add(r);
}
else if (xtr.Name == "Ident")
{
Ident id = new Ident();
id.description = xtr.GetAttribute("Description");
id.offset = Convert.ToInt32(xtr.GetAttribute("Offset"));
id.pointstotagtype = xtr.GetAttribute("PointsToTagType");
id.pointstotagname = xtr.GetAttribute("PointsToTagName");
id.pointstoTagIndex = Map.Functions.ForMeta.FindByNameAndTagType(
id.pointstotagtype, id.pointstotagname);
id.intagtype = xtr.GetAttribute("TagType");
id.intagname = xtr.GetAttribute("TagName");
id.intag = Map.Functions.ForMeta.FindByNameAndTagType(id.intagtype, id.intagname);
this.items.Add(id);
}
else if (xtr.Name == "String")
{
String s = new String();
s.description = xtr.GetAttribute("Description");
s.offset = Convert.ToInt32(xtr.GetAttribute("Offset"));
s.name = xtr.GetAttribute("StringName");
s.intagtype = xtr.GetAttribute("TagType");
s.intagname = xtr.GetAttribute("TagName");
s.intag = Map.Functions.ForMeta.FindByNameAndTagType(s.intagtype, s.intagname);
this.items.Add(s);
}
break;
default:
break;
}
}
xtr.Close();
//
///check for raw
this.rawType = Map.Functions.ForMeta.CheckForRaw(this.type);
if (this.rawType != RawDataContainerType.Empty)
{
this.raw = new RawDataContainer();
this.raw = this.raw.LoadRawFromFile(inputFileName, this);
}
}
