internal void PostProcess(ConvertParameter single)
{
//set all the objects is converted
ProcessConvert(single);
//Set the object is multiObject or not
ProcessMulti(single);
}
public void AllocatePosition(ConvertParameter single)
{
var availLine = ScanAvailableList();
//開始分派線線
for (var i = 0; i < single.ContainerConvertParameter.ListObjectContainer.Count; i++)
{
//目前優先順序
var decideLinePriprity = GetRandNumber(single, i) % availLine;
var line = FindLineIndexFromPriority(decideLinePriprity);
single.ContainerConvertParameter.ListObjectContainer[i].Position = LinePositionDefinition.GetPosition(line);
//被佔用了
_listLineRemainCount[line] = _lineOccupancyCount;
availLine--;
}
//把上一回的全部--;
for (var i = 0; i < _listLineRemainCount.Count; i++)
{
if (_listLineRemainCount[i] > 0)
{
_listLineRemainCount[i]--;
}
}
}
internal void ProcessPosition(ConvertParameter single)
{
//同一群絁E�E皁E��件位置
foreach (var singleTupleHitObjects in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
if (single.ContainerConvertParameter.LayoutNumber == 1) //如果layout只有一個就沒什麼好決定亁E
{
singleTupleHitObjects.ListBaseHitObject[0].ContainerIndex = 0;
singleTupleHitObjects.ListBaseHitObject[0].LayoutIndex = 0;
}
else //兩個以上layout
{
for (var i = 0; i < singleTupleHitObjects.ListBaseHitObject.Count; i++)
{
//目前在哪一個container 裡面皁E哪個index裡面
var layoutindex = GetRandomValue(singleTupleHitObjects, i) % single.ContainerConvertParameter.LayoutNumber;
var remain = layoutindex;
//取得container位置和對應皁Eayoutindex
for (var j = 0; j < single.ContainerConvertParameter.ContainerNumber; j++)
{
var layoutNumberinSingleContainer = single.ContainerConvertParameter.ListObjectContainer[i].ContainerLayerList.Count;
if (remain < layoutNumberinSingleContainer)
{
singleTupleHitObjects.ListBaseHitObject[i].ContainerIndex = j;
singleTupleHitObjects.ListBaseHitObject[i].LayoutIndex = remain;
}
remain = remain - j;
}
}
}
}
}
private RpContainerLine GenerateSingleLayout(ConvertParameter single, RpContainerLineGroup container)
{
var objectContainerLayer = new RpContainerLine(container);
objectContainerLayer.StartTime = single.SliceConvertParameter.StartTime;
objectContainerLayer.EndTime = single.SliceConvertParameter.EndTime;
return(objectContainerLayer);
}
public containerConvertParameter GetParameter(ConvertParameter parameter)
{
var output = new containerConvertParameter();
output.ContainerNumber = ContainerNumber(parameter);
output.LayoutNumber = LayoutNumber(output, parameter);
return(output);
}
internal void PostProcess(ConvertParameter single)
{
//follow the coop on the layout HotObject locate in
ProcessCoop(single);
//set all the objects is converted
ProcessConvert(single);
//Set the object is multiObject or not
ProcessMulti(single);
}
/// <summary>
/// all the layout will have non-coop
/// </summary>
private void GenerateNonCoop(ConvertParameter single)
{
foreach (var sligleContainer in single.ContainerConvertParameter.ListObjectContainer)
{
foreach (var layout in sligleContainer.ContainerLayerList)
{
layout.Coop = RpBaseHitObjectType.Coop.Both;
}
}
}
private RpContainerLineGroup GenerateSingleContainer(ConvertParameter single)
{
var objectContainer = new RpContainerLineGroup(single.SliceConvertParameter.StartTime);
objectContainer.StartTime = single.SliceConvertParameter.StartTime;
objectContainer.EndTime = single.SliceConvertParameter.EndTime;
objectContainer.BPM = single.SliceConvertParameter.BPM;
objectContainer.Velocity = single.SliceConvertParameter.Volocity;
return(objectContainer);
}
/// <summary>
/// the object is convert from other beatmap or RP beatmap
/// </summary>
/// <param name="single"></param>
private void ProcessConvert(ConvertParameter single)
{
//同一群絁E�E皁E��件位置
foreach (var singleTupleHitObjects in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
foreach (var singleObject in singleTupleHitObjects.ListBaseHitObject)
{
singleObject.Convert = RpBaseObjectType.Convert.Convert;
}
}
}
/// <summary>
/// the object is convert from other beatmap or RP beatmap
/// </summary>
/// <param name="single"></param>
private void ProcessConvert(ConvertParameter single)
{
//蜷御ｸ�鄒､邨・・ｽE・ｽE逧・・ｽE・ｽ・ｽE・ｽ莉ｶ菴咲ｽｮ
foreach (var singleTupleHitObjects in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
foreach (var singleObject in singleTupleHitObjects.ListBaseHitObject)
{
singleObject.Convert = Convert.Convert;
}
}
}
/// <summary>
/// Process coop
/// </summary>
/// <param name="single"></param>
private void ProcessCoop(ConvertParameter single)
{
//同一群絁E�E皁E��件位置
foreach (var singleTupleHitObjects in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
foreach (var singleObject in singleTupleHitObjects.ListBaseHitObject)
{
var containerIndex = singleObject.ContainerIndex;
var layoutIndex = singleObject.LayoutIndex;
singleObject.Coop = single.ContainerConvertParameter.ListObjectContainer[containerIndex].ContainerLayerList[layoutIndex].Coop;
}
}
}
/// <summary>
/// use startTime and Endtime to grab the object and return ComvertParameter
/// And calculate number of Container and Layout
/// </summary>
/// <param name="startIndex"></param>
/// <param name="endIndex"></param>
/// <returns></returns>
private ConvertParameter SlicingSingle(int startIndex, int endIndex, float volicity)
{
var single = new ConvertParameter();
//Get Physical Refrence Object
single.ListRefrenceObject = _originalBeatmap.HitObjects.GetRange(startIndex, endIndex - startIndex);
//難度
single.Difficulty = _diffStar;
//Generate Parameter
single.SliceConvertParameter = GetSliceConvertParameterResult(single, volicity);
return(single);
}
public List <SingleHitObjectConvertParameter> GeneratorListHitObject(ConvertParameter single)
{
foreach (var singleHitObject in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
var singleHitObjects = new List <BaseRpHitableObject>();
for (var i = 0; i < singleHitObject.MultiNumber; i++)
{
singleHitObjects.Add(GenerateRpHitObject(singleHitObject, single));
}
singleHitObject.ListBaseHitObject = singleHitObjects;
}
return(single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter);
}
public bool IsCombo(ConvertParameter single, int i)
{
var result = false;
if (single.ListRefrenceObject[i].StartTime - _lastHitObjectTime < DELTA_COMBO_TIME)
{
result = true;
}
else
{
result = false;
}
_lastHitObjectTime = single.ListRefrenceObject[i].StartTime;
return(result);
}
private void Start()
{
MessageBox.Show(_("This process will create a copy of source UTAU DB.\n\nPlease make sure that you are not in violation of the license terms of the DB."),
_("Notice"),
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
lock (mutex_) {
stop_requested_ = false;
}
textLineBuffer.Text = "";
buttonStart.Text = start_button_cancel_text_;
var starter = new ParameterizedThreadStart(DoConvert);
var thread = new Thread(starter);
var parameter = new ConvertParameter(textSourceDb.Text, textDestinationDb.Text);
thread.Start(parameter);
}
private int ContainerNumber(ConvertParameter parameter)
{
var refHitObjectNum = parameter.ListRefrenceObject.Count;
var reruenContainerNumber = 1;
//如果裡面物件越少，Container越多
if (refHitObjectNum / 2 < parameter.Difficulty)
{
reruenContainerNumber = 2;
}
else if (refHitObjectNum < parameter.Difficulty)
{
reruenContainerNumber = 3;
}
return(reruenContainerNumber);
}
/// <summary>
/// Set the object is multiObject or not
/// </summary>
/// <param name="single"></param>
private void ProcessMulti(ConvertParameter single)
{
//同一群絁E�E皁E��件位置
foreach (var singleTupleHitObjects in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
foreach (var singleObject in singleTupleHitObjects.ListBaseHitObject)
{
if (singleTupleHitObjects.ListBaseHitObject.Count > 1)
{
singleObject.Multi = RpBaseHitObjectType.Multi.Multi;
}
else
{
singleObject.Multi = RpBaseHitObjectType.Multi.SingleClick;
}
}
}
}
/// <summary>
/// Set the object is multiObject or not
/// </summary>
/// <param name="single"></param>
private void ProcessMulti(ConvertParameter single)
{
//蜷御ｸ�鄒､邨・・ｽE・ｽE逧・・ｽE・ｽ・ｽE・ｽ莉ｶ菴咲ｽｮ
foreach (var singleTupleHitObjects in single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter)
{
foreach (var singleObject in singleTupleHitObjects.ListBaseHitObject)
{
if (singleTupleHitObjects.ListBaseHitObject.Count > 1)
{
singleObject.RpMultiHit = RpMultiHit.Multi;
}
else
{
singleObject.RpMultiHit = RpMultiHit.SingleClick;
}
}
}
}
public void ProcessType(ConvertParameter single)
{
_singleSlideParameter = single;
_processObjectTypeRandom.SetConvertParameter(_singleSlideParameter);
_processComboObject.SetConvertParameter(_singleSlideParameter);
var tupleCount = _singleSlideParameter.HitObjectConvertParameter.ListSingleHitObjectConvertParameter.Count;
for (var i = 0; i < tupleCount; i++)
{
if (single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter[i].IsCombo)
{
AssignComboTupleShapes(single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter[i], i); //Combo
}
else
{
AssignNormalTupleShapes(single.HitObjectConvertParameter.ListSingleHitObjectConvertParameter[i]); //Normal
}
}
}
/// <summary>
/// Convert pixel data to raman shift data use convert coefficient with interpolation
/// </summary>
/// <param name="para">Destination raman spectrum format</param>
/// <param name="pixelFirstX">Pixel first X</param>
/// <param name="pixelYDatas">Pixel y datas</param>
/// <param name="outRamanXDatas">OUT: Raman x datas</param>
/// <returns>Raman y datas</returns>
public static double[] PiexToRaman(ConvertParameter para, int pixelFirstX, double[] pixelYDatas, out double[] outRamanXDatas)
{
outRamanXDatas = null;
//X校正系数为3阶，共4个参数, Y轴校正为5阶，共6个参数
if (para == null || para.convertCoefs == null || para.convertCoefs.Length != 4 ||
pixelFirstX < 0 || pixelYDatas == null || pixelYDatas.Length < 5 ||
para.ramanLastX <= para.ramanFirstX || para.ramanFirstX < 0 || para.ramanDataCount < 1)
{
ErrorString = "Invalid Parameters";
return(null);
}
//********** 按照xRamanStep指定的步长，将pixelData中的像素光谱转换到拉曼光谱, 像素谱中的X值为0到length-1 ****/
int xLen = pixelYDatas.Length;
//先使用X校正后的系数将nirstRData中的X轴转换到波数
double[] xcoef = para.convertCoefs;
double[] tempRamanX = new double[xLen];
for (int i = pixelFirstX; i < pixelFirstX + xLen; i++) //像素谱的X轴数值从firstPixelX到pxielYDatas.Length-firstPixelX
{
double tempi = i;
tempRamanX[i - pixelFirstX] = xcoef[0] + xcoef[1] * tempi + xcoef[2] * tempi * tempi + xcoef[3] * tempi * tempi * tempi;
}
//对Raman光谱重新插值
List <double[]> datas = new List <double[]>()
{
tempRamanX, pixelYDatas
};
datas = Ai.Hong.Algorithm.PreProcessor.SplineCubicInterpolation(datas, para.ramanFirstX, para.ramanLastX, para.ramanDataCount);
if (datas == null || datas.Count != 2)
{
ErrorString = Ai.Hong.Algorithm.PreProcessor.ErrorString;
return(null);
}
outRamanXDatas = datas[0];
return(datas[1]);
}
//parameter
/// <summary>
/// Generators the object by parameter.
/// </summary>
internal List <RpContainerLineGroup> GetListContainer(ConvertParameter single)
{
var returnContainer = new List <RpContainerLineGroup>();
var listLayout = new List <RpContainerLine>();
//container number
for (var i = 0; i < single.ContainerConvertParameter.ContainerNumber; i++)
{
returnContainer.Add(GenerateSingleContainer(single));
//decide this container shouble allocate number of layout
listLayout.Add(GenerateSingleLayout(single, returnContainer[i]));
// container layout number;
//TODO : adjust it later
returnContainer[i].ListContainObject[0] = listLayout[i];
}
return(returnContainer);
}
/// <summary>
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
public SliceConvertParameter GetSliceConvertParameterResult(ConvertParameter result, float volicity)
{
//decide the number of container and layout
var sliceConvertParameter = new SliceConvertParameter();
//startTime
sliceConvertParameter.StartTime = result.ListRefrenceObject[0].StartTime;
//EndTime
var endIndex = result.ListRefrenceObject.Count - 1;
double lastHitObjectDuration = 0;
sliceConvertParameter.EndTime = result.ListRefrenceObject[endIndex].StartTime + lastHitObjectDuration;
//TODO : get the BGM by startTime
//BPM
sliceConvertParameter.BPM = 60000 / _originalBeatmap.ControlPointInfo.TimingPointAt(sliceConvertParameter.StartTime).BeatLength;
sliceConvertParameter.Volocity = volicity;
return(sliceConvertParameter);
}
/// <summary>
/// DecideCoop
/// </summary>
/// <param name="single"></param>
internal void DecideCoop(ConvertParameter single)
{
var layoutNumber = 0;
//Get the number of layoutNumber;
foreach (var sligleContainer in single.ContainerConvertParameter.ListObjectContainer)
{
layoutNumber = layoutNumber + sligleContainer.ContainerLayerList.Count;
}
//Get how many number of the HitObject
var refCount = single.ListRefrenceObject.Count;
//decide use coop or not
if (refCount < _coopNumber)
{
GenerateCoop(single);
}
else
{
GenerateNonCoop(single);
}
}
/// <summary>
/// Depend on how many layout and decide the coop
/// </summary>
private void GenerateCoop(ConvertParameter single)
{
var listLayout = new List <RpContainerLine>();
foreach (var sligleContainer in single.ContainerConvertParameter.ListObjectContainer)
{
listLayout.AddRange(sligleContainer.ContainerLayerList);
}
var additionRandomValue = GetRandomValue(single);
for (var i = 0; i < listLayout.Count; i++)
{
if ((i + additionRandomValue) % 2 == 0)
{
listLayout[i].Coop = RpBaseHitObjectType.Coop.LeftOnly;
}
else
{
listLayout[i].Coop = RpBaseHitObjectType.Coop.RightOnly;
}
}
}
public HitObjectConvertParameter Analyse(ConvertParameter single)
{
//打擊物件的參數
var parameter = new HitObjectConvertParameter();
for (var i = 0; i < single.ListRefrenceObject.Count; i++)
{
//單一參數
var singleParameter = new SingleHitObjectConvertParameter();
//有無combo
singleParameter.IsCombo = AnaylseCombo.IsCombo(single, i);
//出現物件數量
singleParameter.MultiNumber = AnaylseMulti.GetMultiNumber(single, i);
//開始時間
singleParameter.StartTime = single.ListRefrenceObject[i].StartTime;
//結束時間
singleParameter.EndTime = single.ListRefrenceObject[i].StartTime;
//增加物件
parameter.ListSingleHitObjectConvertParameter.Add(singleParameter);
}
return(parameter);
}
public RpHitObject GenerateRpHitObject(SingleHitObjectConvertParameter singleHitObject, ConvertParameter single)
{
var rpHitObject = new RpHitObject(single.ContainerConvertParameter.ListObjectContainer[0].ListContainObject[0], singleHitObject.StartTime);
//fake sample
return(rpHitObject);
}
public int GetMultiNumber(ConvertParameter single, int i)
{
if (single.ContainerConvertParameter.LayoutNumber > 1)
return CalRandomNumber(single, i) % single.ContainerConvertParameter.LayoutNumber + 1;
return 1;
}
internal void SetConvertParameter(ConvertParameter singleSlideParameter)
{
_singleSlideParameter = singleSlideParameter;
}
/// <summary>
/// generate readom value by something
/// </summary>
/// <returns></returns>
private int GetRandomValue(ConvertParameter single)
{
return(single.ListRefrenceObject.Count + single.ContainerConvertParameter.ListObjectContainer.Count + 1);
}
/// <summary>
/// Create intensity calibrate data(raman shift format)
/// </summary>
/// <param name="para">raman convert coefficient</param>
/// <param name="standardCalCoefs">2241 standard coefs</param>
/// <param name="pixelFirstX">First x of calibration spectrum</param>
/// <param name="pixelYDatas">Calibratoin sepctrum y datas</param>
/// <param name="userCalCoefs">User calibrate coefs</param>
/// <returns>Intensity calibration datas</returns>
public static double[] GetIntensityCalData(ConvertParameter para, double[] standardCalCoefs, int pixelFirstX, double[] pixelYDatas, double[] userCalCoefs = null)
{
//X校正系数为3阶，共4个参数, Y轴校正为5阶，共6个参数
if (para == null || para.convertCoefs == null || para.convertCoefs.Length != 4 ||
pixelFirstX < 0 || pixelYDatas == null || pixelYDatas.Length < 5 ||
para.ramanLastX <= para.ramanFirstX || para.ramanFirstX < 0 || para.ramanDataCount < 1)
{
ErrorString = "Invalid Parameters";
return(null);
}
if (standardCalCoefs == null || standardCalCoefs.Length < 2)
{
ErrorString = "Invalid Parameters";
return(null);
}
if (userCalCoefs != null && userCalCoefs.Length < 2)
{
ErrorString = "Invalid Parameters";
return(null);
}
//为了防止覆盖，需要克隆一个数组
double[] operateYDatas = new double[pixelYDatas.Length];
Array.Copy(pixelYDatas, operateYDatas, operateYDatas.Length);
//用户自定义校准需要另外处理
if (userCalCoefs != null)
{
//按照像素光谱的格式来拟合用户自定义系数光谱
double[] userCalDatas = PolynomialResult(userCalCoefs, pixelFirstX, 1.0, operateYDatas.Length);
//标准物质像素光谱 = 用户系数拟合光谱 x 替代物光谱像素
for (int i = 0; i < operateYDatas.Length; i++)
{
operateYDatas[i] *= userCalDatas[i];
}
}
//将标准物质像素光谱转换为拉曼谱
double[] ramanXDatas;
double[] ramanYDatas = PiexToRaman(para, pixelFirstX, operateYDatas, out ramanXDatas);
if (ramanYDatas == null)
{
return(null);
}
//标准系数拟合光谱
double[] standardPolyDatas = PolynomialResult(standardCalCoefs, para.ramanFirstX, para.ramanXStep, para.ramanDataCount);
//实际计算为 (Sample Measure / Sample Real ) = (2241 Measure / 2241 Real)
//这里用2241 Real/ 2241 Measure, 出去之后直接乘上 Sample Measure，就得到Sample Real
for (int i = 0; i < ramanYDatas.Length; i++)
{
ramanYDatas[i] = standardPolyDatas[i] / (ramanYDatas[i] == 0 ? 1 : ramanYDatas[i]);
}
double minY = ramanYDatas.Min();
for (int i = 0; i < ramanYDatas.Length; i++)
{
ramanYDatas[i] = ramanYDatas[i] / minY;
}
return(ramanYDatas);
}
private void Start()
{
MessageBox.Show(_("This process will create a copy of source UTAU DB.\n\nPlease make sure that you are not in violation of the license terms of the DB."),
_("Notice"),
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
lock (mutex_) {
stop_requested_ = false;
}
textLineBuffer.Text = "";
buttonStart.Text = start_button_cancel_text_;
var starter = new ParameterizedThreadStart(DoConvert);
var thread = new Thread(starter);
var parameter = new ConvertParameter(textSourceDb.Text, textDestinationDb.Text);
thread.Start(parameter);
}
