public FragmentData VertexShader(VertexData input)
{
FragmentData outValue = new FragmentData();
outValue.Position = input.Position;
outValue.Color = input.Color;
// - Passtrough
return(outValue);
}
void PixelProcessingAndMerge(FragmentData fragmentData, Color materialColor, bool reversedZ = true)
{
var size = fragmentData.index.Count;
for (int i = 0; i < size; i++)
{
var index = fragmentData.index[i];
var currentZ = fragmentData.sv_depth[i];
if (reversedZ && currentZ > depthBuffer[index])
{
colorBuffer[index] = materialColor;
depthBuffer[index] = currentZ;
}
else if (!reversedZ && currentZ < depthBuffer[index])
{
colorBuffer[index] = materialColor;
depthBuffer[index] = currentZ;
}
}
}
public FragmentEffect()
{
EffectData = new FragmentData();
}
public FragmentEffect()
{
EffectData = new FragmentData ();
}
public ActionResult Index(
long[] matterIds,
short[] characteristicLinkIds,
int length,
int step,
bool delta,
bool fourier,
bool growingWindow,
bool autocorrelation,
Notation notation,
Language?language,
Translator?translator,
PauseTreatment?pauseTreatment,
bool?sequentialTransfer,
ImageOrderExtractor?trajectory)
{
return(CreateTask(() =>
{
var characteristicNames = new string[characteristicLinkIds.Length];
var partNames = new List <string> [matterIds.Length];
var starts = new List <int> [matterIds.Length];
var lengthes = new List <int> [matterIds.Length];
var chains = new Chain[matterIds.Length];
var mattersCharacteristics = new object[matterIds.Length];
var calculators = new IFullCalculator[characteristicLinkIds.Length];
var links = new Link[characteristicLinkIds.Length];
matterIds = matterIds.OrderBy(m => m).ToArray();
Dictionary <long, Matter> matters = Cache.GetInstance().Matters.Where(m => matterIds.Contains(m.Id)).ToDictionary(m => m.Id);
for (int k = 0; k < matterIds.Length; k++)
{
long matterId = matterIds[k];
Nature nature = Cache.GetInstance().Matters.Single(m => m.Id == matterId).Nature;
long sequenceId = commonSequenceRepository.GetSequenceIds(new[] { matterId },
notation,
language,
translator,
pauseTreatment,
sequentialTransfer,
trajectory).Single();
chains[k] = commonSequenceRepository.GetLibiadaChain(sequenceId);
}
for (var i = 0; i < characteristicLinkIds.Length; i++)
{
int characteristicLinkId = characteristicLinkIds[i];
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkId);
calculators[i] = FullCalculatorsFactory.CreateCalculator(characteristic);
links[i] = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkId);
}
for (int i = 0; i < chains.Length; i++)
{
CutRule cutRule = growingWindow
? (CutRule) new CutRuleWithFixedStart(chains[i].Length, step)
: new SimpleCutRule(chains[i].Length, step, length);
CutRuleIterator iterator = cutRule.GetIterator();
var fragments = new List <Chain>();
partNames[i] = new List <string>();
starts[i] = new List <int>();
lengthes[i] = new List <int>();
while (iterator.Next())
{
int start = iterator.GetStartPosition();
int end = iterator.GetEndPosition();
var fragment = new List <IBaseObject>();
for (int k = 0; start + k < end; k++)
{
fragment.Add(chains[i][start + k]);
}
fragments.Add(new Chain(fragment));
partNames[i].Add(fragment.ToString());
starts[i].Add(iterator.GetStartPosition());
lengthes[i].Add(fragment.Count);
}
var fragmentsData = new FragmentData[fragments.Count];
for (int k = 0; k < fragments.Count; k++)
{
var characteristics = new double[calculators.Length];
for (int j = 0; j < calculators.Length; j++)
{
characteristics[j] = calculators[j].Calculate(fragments[k], links[j]);
}
fragmentsData[k] = new FragmentData(characteristics, fragments[k].ToString(), starts[i][k], fragments[k].Length);
}
double[][] differenceData = null;
double[][] fourierData = null;
double[][] autocorrelationData = null;
if (delta)
{
differenceData = CalculateDifference(fragmentsData.Select(f => f.Characteristics).ToArray());
}
if (fourier)
{
fourierData = FastFourierTransform.CalculateFastFourierTransform(fragmentsData.Select(f => f.Characteristics).ToArray());
}
if (autocorrelation)
{
autocorrelationData = AutoCorrelation.CalculateAutocorrelation(fragmentsData.Select(f => f.Characteristics).ToArray());
}
mattersCharacteristics[i] = new LocalCharacteristicsData(matters[matterIds[i]].Name,
fragmentsData,
differenceData,
fourierData,
autocorrelationData);
}
for (int l = 0; l < characteristicLinkIds.Length; l++)
{
characteristicNames[l] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[l]);
}
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k], notation);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
var result = new Dictionary <string, object>
{
{ "characteristics", mattersCharacteristics },
{ "notationName", notation.GetDisplayValue() },
{ "starts", starts },
{ "partNames", partNames },
{ "lengthes", lengthes },
{ "characteristicNames", characteristicNames },
{ "matterIds", matterIds },
{ "characteristicsList", characteristicsList },
{ "aligners", EnumHelper.GetSelectList(typeof(Aligner)) },
{ "distanceCalculators", EnumHelper.GetSelectList(typeof(DistanceCalculator)) },
{ "aggregators", EnumHelper.GetSelectList(typeof(Aggregator)) }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
FragmentData ClippingAndRasterization(VaryingData varyingData, int[] indexes)
{
var result = new FragmentData();
var count = indexes.Length;
for (int i = 0; i < count; i += 3)
{
var index0 = indexes[i];
var index1 = indexes[i + 1];
var index2 = indexes[i + 2];
var v0 = new Vector4(varyingData.sv_position[index0].x, varyingData.sv_position[index0].y, varyingData.sv_position[index0].z, 1f) / varyingData.sv_position[index0].w;
var v1 = new Vector4(varyingData.sv_position[index1].x, varyingData.sv_position[index1].y, varyingData.sv_position[index1].z, 1f) / varyingData.sv_position[index1].w;
var v2 = new Vector4(varyingData.sv_position[index2].x, varyingData.sv_position[index2].y, varyingData.sv_position[index2].z, 1f) / varyingData.sv_position[index2].w;
var area = EdgeFunction(v0, v1, v2);
var xMin = Mathf.Max(Mathf.FloorToInt((Mathf.Min(v0.x, v1.x, v2.x) * 0.5f + 0.5f) / pixelSize.x), 0);
var xMax = Mathf.Min(Mathf.CeilToInt((Mathf.Max(v0.x, v1.x, v2.x) * 0.5f + 0.5f) / pixelSize.x) + 1, width);
var yMin = Mathf.Max(Mathf.FloorToInt((Mathf.Min(v0.y, v1.y, v2.y) * 0.5f + 0.5f) / pixelSize.y), 0);
var yMax = Mathf.Min(Mathf.CeilToInt((Mathf.Max(v0.y, v1.y, v2.y) * 0.5f + 0.5f) / pixelSize.y) + 1, height);
for (int x = xMin; x < xMax; x++)
{
for (int y = yMin; y < yMax; y++)
{
var p = new Vector2(x * pixelSize.x, y * pixelSize.y) + pixelSize * 0.5f;
p = p * 2f - new Vector2(1f, 1f);
var w0 = EdgeFunction(v1, v2, p);
var w1 = EdgeFunction(v2, v0, p);
var w2 = EdgeFunction(v0, v1, p);
if (w0 < 0 || w1 < 0 || w2 < 0)
{
// triangle not contains the point
continue;
}
w0 /= area;
w1 /= area;
w2 /= area;
var interpolated_z = v0.z * w0 + v1.z * w1 + v2.z * w2;
var interpolated_w = v0.w * w0 + v1.w * w1 + v2.w * w2;
if (interpolated_z < 0f || interpolated_z > 1f)
{
// clip fragments outside the near/far planes
continue;
}
// perspective correct interpolation
// w0 = w0 * v0.w / interpolated_w;
// w1 = w1 * v1.w / interpolated_w;
// w2 = w2 * v2.w / interpolated_w;
// var varying = varying0 * w0 + varying1 * w1 + varying2 * w2;
var depth = interpolated_z;
var index = y * width + x;
result.index.Add(index);
result.sv_depth.Add(depth);
}
}
}
return(result);
}
public SVector4 FragmentShader(FragmentData input)
{
// - Passtrough
return(input.Color);
}
