public List <int> PointsOfType(PhonemeType type, bool virtuals = true)
{
return(type == PhonemeType.Consonant ? ConsonantPoints :
(type == PhonemeType.Vowel ? VowelPoints :
(virtuals ? VirtualRestPoints : RestPoints)
));
}
public Color ConfiguredColor(string itemName, PhonemeType phoneme, LipSyncMapItem item = null)
{
Color retVal = Color.Black;
if (item == null)
{
item = FindMapItem(itemName);
}
if (item != null)
{
if (this.IsMatrix)
{
if (item.ElementColors[phoneme] != Color.Black)
{
retVal = item.ElementColors[phoneme];
}
}
else
{
if (item.PhonemeList[phoneme.ToString()] == true)
{
HSV hsvVal = HSV.FromRGB(new RGB(item.ElementColor));
hsvVal.V = 1;
retVal = hsvVal.ToRGB().ToArgb();
}
}
}
return(retVal);
}
private void HandlePointAdded(double position, PhonemeType type, int i)
{
var points = PointsOfType(type);
points.Add(CreatePoint(position, type, i));
FirePointsChanged();
}
public static List <PhonemeType> TryConvert(string text)
{
List <PhonemeType> wordPhonemes;
List <PhonemeType> retVal = new List <PhonemeType>();
List <PhonemeType> tmpList = new List <PhonemeType>();
string[] words = text.Split();
foreach (string word in words)
{
mouthDict.TryGetValue(word.ToUpper(), out wordPhonemes);
if (wordPhonemes != null)
{
PhonemeType lastPT = PhonemeType.Unknown;
//Coallesce list to remove uneeded phonemes
foreach (PhonemeType pt in wordPhonemes)
{
if (pt != lastPT)
{
retVal.Add(pt);
lastPT = pt;
}
}
}
}
return(retVal);
}
public PapagayoPhoneme(string pair, PapagayoPhoneme lastObj, string lyricWord = null)
{
m_type = PhonemeType.Rest;
m_Text = "Rest";
m_lyricWord = lyricWord ?? "";
if (pair != null)
{
string[] split = pair.Split(' ');
if (split.Length == 2)
{
StartFrame = Convert.ToInt32(split[0].TrimStart(null));
m_Text = split[1].TrimStart(null);
try
{
m_type = (PhonemeType)Enum.Parse(typeof(PhonemeType), m_Text);
}
catch (Exception)
{
m_type = PhonemeType.Rest;
}
if (lastObj != null)
{
lastObj.EndFrame = StartFrame - 1;
}
}
}
}
public LipSyncConvertData(long startTicks, long durTicks, PhonemeType phoneme, string lyricData)
{
StartOffset = new TimeSpan(startTicks);
Duration = new TimeSpan(durTicks);
Phoneme = phoneme;
LyricData = lyricData;
}
private void BuildMapDataFromDialog(PhonemeType phoneme)
{
LipSyncMapItem mapItem;
int numRows = CalcNumDataGridRows;
int numCols = CalcNumDataGridCols;
for (int row = 0; row < numRows; row++)
{
DataRow dr = currentDataTable.Rows[row];
for (int col = 0; col < numCols; col++)
{
mapItem = FindRenderMapItem(row, col);
if (mapItem != null)
{
if (mapItem.ElementColors == null)
{
mapItem.ElementColors = new Dictionary<PhonemeType, Color>();
}
mapItem.ElementColors[phoneme] = (Color)dr[col];
}
}
}
_newMapping.IsMatrix = true;
_newMapping.MatrixStringCount = stringCount;
_newMapping.MatrixPixelsPerString = pixelCount;
_newMapping.ZoomLevel = zoomTrackbar.Value;
_newMapping.LibraryReferenceName = nameTextBox.Text;
}
public double ConfiguredIntensity(string itemName, PhonemeType phoneme, LipSyncMapItem item = null)
{
double retVal = 0;
if (item == null)
{
item = FindMapItem(itemName);
}
if (item != null)
{
if (this.IsMatrix)
{
if (item.ElementColors[phoneme] != Color.Black)
{
HSV hsvVal = HSV.FromRGB(new RGB(item.ElementColors[phoneme]));
retVal = hsvVal.V;
//retVal = 1.0;
}
}
else
{
if (item.PhonemeList[phoneme.ToString()] == true)
{
HSV hsvVal = HSV.FromRGB(new RGB(item.ElementColor));
retVal = hsvVal.V;
}
}
}
return(retVal);
}
private void UpdatePointsOfType(PhonemeType type)
{
var points = PointsOfType(type);
var projectPoints = ProjectLine.PointsOfType(type, virtuals: false);
var phonemes = ProjectLine.Recline.PhonemesOfType(type);
for (int i = 0; i < points.Count; i++)
{
var point = points[i];
var wasEnabled = point.IsEnabled;
point.IsEnabled = i < projectPoints.Count;
if (point.IsEnabled)
{
var position = Settings.RealToViewX(projectPoints[i]);
point.Position = position;
point.Update(PointIsLeft(type, i), phonemes[i / 2].Alias);
}
else
{
point.Position = -1;
}
if (IsEnabled != wasEnabled)
{
point.FireChanged();
}
}
}
public LipSyncConvertData(long startTicks, long durTicks, PhonemeType phoneme, string lyricData)
{
StartOffset = new TimeSpan(startTicks);
Duration = new TimeSpan(durTicks);
Phoneme = phoneme;
LyricData = lyricData;
}
private void ResetPointsOfType(PhonemeType type)
{
ProjectLine.PointsOfType(type, false).Clear();
ProjectLine.ZonesOfType(type).Clear();
PointsOfType(type).Clear();
ZonesOfType(type).Clear();
FirePointsChanged();
}
public PapagayoPhoneme(PapagayoPhoneme copyObj)
{
this.m_state = copyObj.m_state;
this.m_Text = copyObj.m_Text;
this.StartFrame = copyObj.StartFrame;
this.EndFrame = copyObj.EndFrame;
this.m_type = copyObj.m_type;
}
public int DeletePoint(int position, PhonemeType type)
{
var points = PointsOfType(type, virtuals: false);
var i = points.IndexOf(position);
points.Remove(position);
UpdateZones();
ProjectLinePointsChanged();
return(i);
}
public bool MustSkipPhoneme(PhonemeType phonemeType, int position)
{
if (phonemeType == PhonemeType.Consonant)
{
return(SkipC.Contains(position));
}
if (phonemeType == PhonemeType.Vowel)
{
return(SkipV.Contains(position));
}
return(SkipR.Contains(position));
}
public (int, int) MovePoint(int position1, int position2, PhonemeType type)
{
var points = PointsOfType(type, virtuals: false);
int i = points.IndexOf(position1);
if (i > -1)
{
points[i] = position2;
}
points.Sort();
UpdateZones();
ProjectLinePointsChanged();
return(i, points.IndexOf(position2));
}
public void AddPoint(double position, PhonemeType type)
{
position = CheckPosition(position);
if (position == -1)
{
return;
}
var i = ProjectLine.AddPoint(Settings.ViewToRealX(position), type);
if (i == -1)
{
return;
}
OnPointAdded(position, type, i);
}
public List <int> GetSkippedPhonemesOfType(PhonemeType type)
{
if (type == PhonemeType.Consonant)
{
return(SkipC);
}
else if (type == PhonemeType.Rest)
{
return(SkipR);
}
else
{
return(SkipV);
}
}
public bool MustSkipPhoneme(string filename, PhonemeType phonemeType, int position)
{
if (!IsConfigured())
{
return(false); // without mask file we generate all possible
}
if (wavGroupsByFilename.ContainsKey(filename))
{
var groups = wavGroupsByFilename[filename];
foreach (var wavGroup in groups)
{
return(wavGroup.MustSkipPhoneme(phonemeType, position));
}
}
return(false); // skip only if all groups ask for it
}
public void MovePoint(double position1, double position2, PhonemeType type)
{
position2 = GetProjectLineContainer().CheckPosition(position2);
ProjectLine.MovePoint(Settings.ViewToRealX(position1), Settings.ViewToRealX(position2), type);
var points = PointsOfType(type);
for (int i = 0; i < points.Count; i++)
{
if (points[i].Position == position1)
{
points[i].Position = position2;
break;
}
}
FirePointsChanged();
}
public void DeletePoint(double position, PhonemeType type)
{
position = GetProjectLineContainer().CheckPosition(position);
ProjectLine.DeletePoint(Settings.ViewToRealX(position), type);
var points = PointsOfType(type);
foreach (var point in points)
{
if (point.Position == position)
{
points.Remove(point);
break;
}
}
FirePointsChanged();
}
public Phoneme(PhonemeType type, string value, PhonemeExample exampleWord, string exampleTranscription, string description)
{
Type = type;
Value = value;
if (exampleWord != null)
{
if (exampleTranscription is null)
{
throw new ArgumentNullException(nameof(exampleTranscription), $"{nameof(exampleTranscription)} cannot be null if {nameof(exampleWord)} is not null.");
}
ExampleWord = exampleWord;
ExampleTranscription = exampleTranscription;
}
Description = description;
}
// renders the given node to the internal ElementData dictionary. If the given node is
// not a element, will recursively descend until we render its elements.
private void RenderNodes()
{
var renderNodes = TargetNodes.SelectMany(x => x.GetNodeEnumerator());
if (LipSyncMode == LipSyncMode.MarkCollection)
{
SetupMarks();
}
PhonemeType phoneme = _data.StaticPhoneme;
if (MappingType == MappingType.Map)
{
if (!_library.Library.ContainsKey(_data.PhonemeMapping))
{
_data.PhonemeMapping = _library.DefaultMappingName;
}
LipSyncMapData mapData;
if (_library.Library.TryGetValue(_data.PhonemeMapping, out mapData))
{
if (mapData.IsMatrix)
{
RenderMapMatrix(mapData, phoneme);
}
else
{
//We should never get here becasue we no longer have string maps
Logging.Error("Trying to render as deprecated string maps!");
foreach (var element in renderNodes)
{
RenderMapElements(mapData, element, phoneme);
}
}
}
}
else
{
foreach (var element in renderNodes)
{
RenderPropertyMapElements(element, phoneme);
}
}
}
private WavPointViewModel CreatePoint(double p, PhonemeType type, int i)
{
var point = new WavPointViewModel(p, type, GetPointLabel(type, i), PointIsLeft(type, i), Height);
point.WavPointChanged += delegate(double position1, double position2)
{
MovePoint(position1, position2, type);
};
point.WavPointDeleted += delegate(double position)
{
DeletePoint(position, type);
};
point.RegenerateOtoRequest += delegate
{
GetProjectLineContainer().RequestChangeMode(point.Type);
GetProjectLineContainer().RequestGenerateOto();
};
return(point);
}
private void BuildZones(ObservableCollection <WavZoneViewModel> zones, PhonemeType type)
{
if (ProjectLine == null)
{
return;
}
var points = ProjectLine.PointsOfType(type);
zones.Clear();
var kindaWitdh = Width > 0 ? Width : 2000;
for (int i = 0; i + 1 < points.Count; i += 2)
{
var pIn = Settings.RealToViewX(points[i]);
var pOut = Settings.RealToViewX(points[i + 1]);
zones.Add(new WavZoneViewModel(type, pIn, pOut, kindaWitdh, (int)Height));
}
return;
}
public double ConfiguredIntensity(string itemName, PhonemeType phoneme, LipSyncMapItem item = null)
{
double retVal = 0;
if (item == null)
{
item = FindMapItem(itemName);
}
if (item != null)
{
if (!this.IsMatrix)
{
if (item.PhonemeList[phoneme.ToString()] == true)
{
retVal = HSV.VFromRgb(item.ElementColor);
}
}
}
return(retVal);
}
public int AddPoint(int position, PhonemeType type)
{
var points = PointsOfType(type);
var phonemes = Recline.PhonemesOfType(type);
var neededCount = phonemes.Count * 2;
if (points.Count >= neededCount)
{
return(-1);
}
var realPhonemes = PointsOfType(type, virtuals: false);
if (realPhonemes.Contains(position))
{
return(-1);
}
realPhonemes.Add(position);
realPhonemes.Sort();
UpdateZones();
ProjectLinePointsChanged();
return(realPhonemes.IndexOf(position));
}
public bool CanAddPoint(PhonemeType phonemeType, ProjectLine projectLine)
{
if (projectLine.Recline == null)
{
return(false);
}
var phonemes = projectLine.Recline.PhonemesOfType(phonemeType);
var neededCount = phonemes.Count * 2;
var realPhonemes = projectLine.PointsOfType(phonemeType, virtuals: false).Count;
var canIfNoSkip = realPhonemes < neededCount;
if (!IsConfigured())
{
return(canIfNoSkip);
}
var filename = projectLine.Recline.Name;
if (!wavGroupsByFilename.ContainsKey(filename))
{
return(canIfNoSkip);
}
var wavGroup = wavGroupsByFilename[filename][0];
var skips = wavGroup.GetSkippedPhonemesOfType(phonemeType);
var neededByGroup = 0;
for (var i = 0; i < phonemes.Count; i++)
{
if (!skips.Contains(i))
{
neededByGroup += 2;
}
}
return(realPhonemes < neededByGroup);
}
// renders the given node to the internal ElementData dictionary. If the given node is
// not a element, will recursively descend until we render its elements.
private void RenderNode(ElementNode node)
{
EffectIntents result;
LipSyncMapData mapData = null;
List <ElementNode> renderNodes = TargetNodes.SelectMany(x => x.GetNodeEnumerator()).ToList();
if (_data.PhonemeMapping != null)
{
if (!_library.Library.ContainsKey(_data.PhonemeMapping))
{
_data.PhonemeMapping = _library.DefaultMappingName;
}
PhonemeType phoneme = _data.StaticPhoneme;
if (_library.Library.TryGetValue(_data.PhonemeMapping, out mapData))
{
renderNodes.ForEach(delegate(ElementNode element)
{
LipSyncMapItem item = mapData.FindMapItem(element.Name);
if (item != null)
{
if (mapData.PhonemeState(element.Name, _data.StaticPhoneme.ToString(), item))
{
var level = new SetLevel.SetLevel();
level.TargetNodes = new ElementNode[] { element };
level.Color = mapData.ConfiguredColor(element.Name, phoneme, item);
level.IntensityLevel = mapData.ConfiguredIntensity(element.Name, phoneme, item);
level.TimeSpan = TimeSpan;
result = level.Render();
_elementData.Add(result);
}
}
});
}
}
}
public PapagayoPhoneme(string pair, PapagayoPhoneme lastObj)
{
m_type = PhonemeType.REST;
m_Text = "Rest";
if (pair != null)
{
string[] split = pair.Split(' ');
if (split.Length == 2)
{
StartFrame = Convert.ToInt32(split[0].TrimStart(null));
m_Text = split[1].TrimStart(null);
try
{
m_type = (PhonemeType)Enum.Parse(typeof(PhonemeType), m_Text);
}
catch (Exception)
{
m_type = PhonemeType.REST;
}
if (lastObj != null)
{
lastObj.EndFrame = StartFrame - 1;
}
}
}
}
public double ConfiguredIntensity(string itemName, PhonemeType phoneme, LipSyncMapItem item = null)
{
double retVal = 0;
if (item == null)
{
item = FindMapItem(itemName);
}
if (item != null)
{
if (this.IsMatrix)
{
if (item.ElementColors[phoneme] != Color.Black)
{
HSV hsvVal = HSV.FromRGB(new RGB(item.ElementColors[phoneme]));
retVal = hsvVal.V;
//retVal = 1.0;
}
}
else
{
if (item.PhonemeList[phoneme.ToString()] == true)
{
HSV hsvVal = HSV.FromRGB(new RGB(item.ElementColor));
retVal = hsvVal.V;
}
}
}
return retVal;
}
public Color ConfiguredColor(string itemName, PhonemeType phoneme, LipSyncMapItem item = null)
{
Color retVal = Color.Black;
if (item == null)
{
item = FindMapItem(itemName);
}
if (item != null)
{
if (this.IsMatrix)
{
if (item.ElementColors[phoneme] != Color.Black)
{
retVal = item.ElementColors[phoneme];
}
}
else
{
if (item.PhonemeList[phoneme.ToString()] == true)
{
HSV hsvVal = HSV.FromRGB(new RGB(item.ElementColor));
hsvVal.V = 1;
retVal = hsvVal.ToRGB().ToArgb();
}
}
}
return retVal;
}
public PapagayoPhoneme(PapagayoPhoneme copyObj)
{
this.m_state = copyObj.m_state;
this.m_Text = copyObj.m_Text;
this.StartFrame = copyObj.StartFrame;
this.EndFrame = copyObj.EndFrame;
this.m_type = copyObj.m_type;
}
public LipSyncConvertData(TimeSpan start, TimeSpan dur, PhonemeType phoneme)
{
StartOffset = start;
Duration = dur;
Phoneme = phoneme;
}
private void RenderPropertyMapElements(IElementNode element, PhonemeType phoneme)
{
var fm = element.Properties.Get(FaceDescriptor.ModuleId) as FaceModule;
if (fm == null)
{
return;
}
if (fm.IsFaceComponentType(FaceComponent.Outlines) && ShowOutline)
{
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
else if (fm.IsFaceComponentType(FaceComponent.EyesOpen) && EyeMode == EyeMode.Open)
{
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
if (fm.IsFaceComponentType(FaceComponent.EyesClosed) && EyeMode == EyeMode.Closed)
{
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
else
{
if (LipSyncMode == LipSyncMode.MarkCollection && _marks != null)
{
TimeSpan lastMarkTime = StartTime;
foreach (var mark in _marks)
{
if (!AllowMarkGaps)
{
var gapDuration = mark.StartTime - lastMarkTime;
if (gapDuration.TotalMilliseconds > 10 && fm.PhonemeState("REST"))
{
//Fill the gap with a rest
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, gapDuration);
result.OffsetAllCommandsByTime(lastMarkTime - StartTime);
_elementData.Add(result);
}
lastMarkTime = mark.EndTime;
}
if (fm.PhonemeState(mark.Text))
{
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, mark.Duration);
result.OffsetAllCommandsByTime(mark.StartTime - StartTime);
_elementData.Add(result);
}
}
if (!AllowMarkGaps)
{
var gapDuration = StartTime + TimeSpan - lastMarkTime;
if (gapDuration.TotalMilliseconds > 10 && fm.PhonemeState("REST"))
{
//Fill the gap with a rest
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, gapDuration);
result.OffsetAllCommandsByTime(lastMarkTime - StartTime);
_elementData.Add(result);
}
}
}
else
{
if (fm.PhonemeState(phoneme.ToString()))
{
var colorVal = fm.ConfiguredColorAndIntensity();
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
}
}
}
private void RenderMapMatrix(LipSyncMapData mapData, PhonemeType phoneme)
{
SetupPictureEffect();
if (LipSyncMode == LipSyncMode.MarkCollection)
{
TimeSpan lastMarkTime = StartTime;
foreach (var mark in _marks)
{
if (!AllowMarkGaps)
{
var gapDuration = mark.StartTime - lastMarkTime;
if (gapDuration.TotalMilliseconds > 10)
{
//Fill the gap with a rest
var restImage = mapData.ImageForPhoneme("REST");
if (restImage != null)
{
_thePic.StartTime = mark.StartTime - StartTime - gapDuration;
_thePic.Image = restImage;
_thePic.TimeSpan = gapDuration;
_thePic.MarkDirty();
var result = _thePic.Render();
result.OffsetAllCommandsByTime(lastMarkTime - StartTime);
_elementData.Add(result);
}
}
lastMarkTime = mark.EndTime;
}
var image = mapData.ImageForPhoneme(mark.Text);
if (image != null)
{
_thePic.StartTime = mark.StartTime - StartTime;
_thePic.Image = image;
_thePic.TimeSpan = mark.Duration;
_thePic.MarkDirty();
var result = _thePic.Render();
result.OffsetAllCommandsByTime(mark.StartTime - StartTime);
_elementData.Add(result);
}
}
if (!AllowMarkGaps)
{
_thePic.StartTime = lastMarkTime - StartTime;
var gapDuration = StartTime + TimeSpan - lastMarkTime;
if (gapDuration.TotalMilliseconds > 10)
{
//Fill the gap with a rest
var restImage = mapData.ImageForPhoneme("REST");
if (restImage != null)
{
_thePic.Image = restImage;
_thePic.TimeSpan = gapDuration;
_thePic.MarkDirty();
var result = _thePic.Render();
result.OffsetAllCommandsByTime(lastMarkTime - StartTime);
_elementData.Add(result);
}
}
}
}
else
{
var image = mapData.ImageForPhoneme(phoneme);
if (image != null)
{
_thePic.Image = image;
_thePic.TimeSpan = TimeSpan;
_thePic.MarkDirty();
var result = _thePic.Render();
_elementData.Add(result);
}
}
TearDownPictureEffect();
}
private void RenderMapElements(LipSyncMapData mapData, IElementNode element, PhonemeType phoneme)
{
LipSyncMapItem item = mapData.FindMapItem(element.Id);
if (item == null)
{
return;
}
if (mapData.IsFaceComponentType(FaceComponent.Outlines, item))
{
var colorVal = mapData.ConfiguredColorAndIntensity(item);
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
else if (mapData.IsFaceComponentType(FaceComponent.EyesOpen, item))
{
var colorVal = mapData.ConfiguredColorAndIntensity(item);
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
else
{
if (LipSyncMode == LipSyncMode.MarkCollection && _marks != null)
{
TimeSpan lastMarkTime = StartTime;
foreach (var mark in _marks)
{
if (!AllowMarkGaps)
{
var gapDuration = mark.StartTime - lastMarkTime;
if (gapDuration.TotalMilliseconds > 10 && mapData.PhonemeState("REST", item))
{
//Fill the gap with a rest
var colorVal = mapData.ConfiguredColorAndIntensity(item);
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, gapDuration);
result.OffsetAllCommandsByTime(lastMarkTime - StartTime);
_elementData.Add(result);
}
lastMarkTime = mark.EndTime;
}
if (mapData.PhonemeState(mark.Text, item))
{
var colorVal = mapData.ConfiguredColorAndIntensity(item);
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, mark.Duration);
result.OffsetAllCommandsByTime(mark.StartTime - StartTime);
_elementData.Add(result);
}
}
if (!AllowMarkGaps)
{
var gapDuration = StartTime + TimeSpan - lastMarkTime;
if (gapDuration.TotalMilliseconds > 10 && mapData.PhonemeState("REST", item))
{
//Fill the gap with a rest
var colorVal = mapData.ConfiguredColorAndIntensity(item);
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, gapDuration);
result.OffsetAllCommandsByTime(lastMarkTime - StartTime);
_elementData.Add(result);
}
}
}
else
{
if (mapData.PhonemeState(phoneme.ToString(), item))
{
var colorVal = mapData.ConfiguredColorAndIntensity(item);
var result = CreateIntentsForElement(element, colorVal.Item1, colorVal.Item2, TimeSpan);
_elementData.Add(result);
}
}
}
}
