public void Initialize(Feature feature, IEnumerable <Tuple <Instance, double> > instances)
{
_initialized = true;
_instances = instances;
if (Model == null)
{
throw new InvalidOperationException("Model is null");
}
if (ClassFeature.FeatureType != FeatureType.Nominal)
{
throw new InvalidOperationException("Cannot use this iterator on non-nominal class");
}
if (!feature.IsOrdered)
{
throw new InvalidOperationException("Cannot use this iterator on non-ordered feature");
}
_feature = feature;
CurrentDistribution = new double[2][];
sorted = _instances.Where(x => !FeatureValue.IsMissing(x.Item1[feature])).OrderBy(x => x.Item1[feature]).ToArray();
CurrentDistribution[0] = new double[(ClassFeature as NominalFeature).Values.Length];
CurrentDistribution[1] = sorted.FindDistribution(ClassFeature);
if (sorted.Length == 0)
{
return;
}
_currentIndex = -1;
_lastClassValue = FindNextClass(0);
}
public string Add([FromBody] FeatureValue <object> value)
{
dynamic featureValue;
switch (value.Value)
{
case bool booleanVal:
featureValue = new FeatureValue <bool> {
Value = booleanVal
};
break;
case long longVal:
featureValue = new FeatureValue <long> {
Value = longVal
};
break;
case string stringVal:
featureValue = new FeatureValue <string> {
Value = stringVal
};
break;
default:
featureValue = value;
break;
}
return(_featureValueService.AddFeatureValue(featureValue));
}
public void Initialize(Feature feature, IEnumerable <Tuple <Instance, double> > instances)
{
_instances = instances;
if (Model == null)
{
throw new InvalidOperationException("Model is null");
}
if (feature.FeatureType != FeatureType.Integer && feature.FeatureType != FeatureType.Double)
{
throw new InvalidOperationException("Cannot use this iterator on non-numeric feature");
}
_feature = feature;
CurrentDistribution = new double[4][];
_sorted =
_instances.Where(x => !FeatureValue.IsMissing(x.Item1[feature])).OrderBy(x => x.Item1[feature]).ToArray();
if (_sorted.Length == 0)
{
return;
}
CurrentDistribution[0] = new double[5];
_initialized = true;
bestResultWasFound = false;
}
private async Task <FeatureValue> FindOrCreate(FeatureServicesContext db, string apiKey, string applicationName, string name, string newValue, string internalType)
{
var exists = await db.FeatureValue
.Where(t => !t.IsDeleted && !t.TenantConfiguration.IsDeleted &&
t.TenantConfiguration.Name == apiKey &&
t.Name == name &&
t.ApplicationName == applicationName)
.FirstOrDefaultAsync();
if (exists == null)
{
var api = await db.TenantConfiguration.SingleAsync(q => q.Name == apiKey);
exists = new FeatureValue
{
TenantConfigurationId = api.Id,
ApplicationName = applicationName,
Name = name,
Value = newValue,
InternalType = internalType
};
await db.FeatureValue.AddAsync(exists);
}
return(exists);
}
public async Task SetFeatureValue(string apiKey, string applicationName, string name, string value, string internalType)
{
using (var db = GetDb())
{
var exists = await db.FeatureValue
.Where(t => !t.IsDeleted && !t.TenantConfiguration.IsDeleted &&
t.TenantConfiguration.Name == apiKey &&
t.Name == name &&
t.ApplicationName == applicationName)
.FirstOrDefaultAsync();
if (exists == null)
{
var api = await db.TenantConfiguration.SingleAsync(q => q.Name == apiKey);
exists = new FeatureValue
{
TenantConfigurationId = api.Id,
ApplicationName = applicationName,
Name = name,
Value = value,
InternalType = internalType
};
await db.FeatureValue.AddAsync(exists);
}
else
{
exists.Value = value;
exists.Created = DateTime.UtcNow;
}
await db.SaveChangesAsync();
}
}
private IQueryable <T> ApplyFilter(IQueryable <T> data, Feature feature, FeatureValue featureValue)
{
if (featureValue is ContiniousFeatureValue)
{
var continiousFeatureValue = featureValue as ContiniousFeatureValue;
var featureExpression = (feature.Selector as LambdaExpression).Body;
var result = data;
if (continiousFeatureValue.From != null)
{
var expression1 = Expression.GreaterThanOrEqual(featureExpression, Expression.Constant(continiousFeatureValue.From));
var lambdaExpression1 = Expression.Lambda <Func <T, bool> >(expression1, (feature.Selector as LambdaExpression).Parameters);
result = result.Where(lambdaExpression1);
}
if (continiousFeatureValue.To != null)
{
var expression2 = Expression.LessThan(featureExpression, Expression.Constant(continiousFeatureValue.To));
var lambdaExpression2 = Expression.Lambda <Func <T, bool> >(expression2, (feature.Selector as LambdaExpression).Parameters);
result = result.Where(lambdaExpression2);
}
return(result);
}
else
{
var discreteFeatureValue = featureValue as DiscreteFeatureValue;
var expression = Expression.Equal((feature.Selector as LambdaExpression).Body, Expression.Constant(discreteFeatureValue.Value));
var lambdaExpression = Expression.Lambda <Func <T, bool> >(expression, (feature.Selector as LambdaExpression).Parameters);
return(data.Where(lambdaExpression));
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public boolean predict(org.maltparser.core.feature.FeatureVector featureVector, org.maltparser.parser.history.action.SingleDecision decision, boolean one_prediction) throws org.maltparser.core.exception.MaltChainedException
public virtual bool predict(FeatureVector featureVector, SingleDecision decision, bool one_prediction)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.ArrayList<org.maltparser.ml.lib.MaltFeatureNode> featureList = new java.util.ArrayList<org.maltparser.ml.lib.MaltFeatureNode>();
List <MaltFeatureNode> featureList = new List <MaltFeatureNode>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int size = featureVector.size();
int size = featureVector.Count;
for (int i = 1; i <= size; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.core.feature.value.FeatureValue featureValue = featureVector.getFeatureValue(i-1);
FeatureValue featureValue = featureVector.GetFeatureValue(i - 1);
if (featureValue != null && !(excludeNullValues == true && featureValue.NullValue))
{
if (!featureValue.Multiple)
{
SingleFeatureValue singleFeatureValue = (SingleFeatureValue)featureValue;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int index = featureMap.getIndex(i, singleFeatureValue.getIndexCode());
int index = featureMap.getIndex(i, singleFeatureValue.IndexCode);
if (index != -1 && singleFeatureValue.Value != 0)
{
featureList.Add(new MaltFeatureNode(index, singleFeatureValue.Value));
}
}
else
{
foreach (int?value in ((MultipleFeatureValue)featureValue).Codes)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int v = featureMap.getIndex(i, value);
int v = featureMap.getIndex(i, value.Value);
if (v != -1)
{
featureList.Add(new MaltFeatureNode(v, 1));
}
}
}
}
}
try
{
if (one_prediction)
{
decision.KBestList.add(model.predict_one(featureList.ToArray()));
}
else
{
decision.KBestList.addList(model.predict(featureList.ToArray()));
}
}
catch (System.OutOfMemoryException e)
{
throw new LibException("Out of memory. Please increase the Java heap size (-Xmx<size>). ", e);
}
return(true);
}
public ActionResult DeleteConfirmed(int id)
{
FeatureValue featureValue = db.FeatureValues.Find(id);
db.FeatureValues.Remove(featureValue);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Node(Node parent, string featureName, Operator op, FeatureValue threshold, TextClass textClass, List <double> classDist)
{
this.parent = parent;
this.featureName = featureName;
this.op = op;
this.threshold = threshold;
this.textClass = textClass;
this.classDist = classDist;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void update() throws org.maltparser.core.exception.MaltChainedException
public void update()
{
parentFeature.update();
FeatureValue value = parentFeature.FeatureValue;
if (value is SingleFeatureValue)
{
string symbol = ((SingleFeatureValue)value).Symbol;
if (((FeatureValue)value).NullValue)
{
multipleFeatureValue.addFeatureValue(parentFeature.SymbolTable.getSymbolStringToCode(symbol), symbol);
multipleFeatureValue.NullValue = true;
}
else
{
string prefixStr;
if (symbol.Length - prefixLength > 0)
{
prefixStr = symbol.Substring(0, prefixLength);
}
else
{
prefixStr = symbol;
}
int code = table.addSymbol(prefixStr);
multipleFeatureValue.addFeatureValue(code, prefixStr);
multipleFeatureValue.NullValue = false;
}
}
else if (value is MultipleFeatureValue)
{
multipleFeatureValue.reset();
if (((MultipleFeatureValue)value).NullValue)
{
multipleFeatureValue.addFeatureValue(parentFeature.SymbolTable.getSymbolStringToCode(((MultipleFeatureValue)value).FirstSymbol), ((MultipleFeatureValue)value).FirstSymbol);
multipleFeatureValue.NullValue = true;
}
else
{
foreach (string symbol in ((MultipleFeatureValue)value).Symbols)
{
string prefixStr;
if (symbol.Length - prefixLength > 0)
{
prefixStr = symbol.Substring(0, prefixLength);
}
else
{
prefixStr = symbol;
}
int code = table.addSymbol(prefixStr);
multipleFeatureValue.addFeatureValue(code, prefixStr);
multipleFeatureValue.NullValue = true;
}
}
}
}
public static FeatureValueDTO ToDTO(this FeatureValue source)
{
return(source == null
? null
: new FeatureValueDTO(source)
{
Id = source.Id
});
}
public StyleFeatureValueDTO ComposeFeatureValue(IUnitOfWork db,
string featureName,
string featureValue)
{
StyleFeatureValueDTO result = null;
var feature = db.Features.GetAll().FirstOrDefault(f => f.Name == featureName);
if (feature != null)
{
if (feature.ValuesType == (int)FeatureValuesType.DropDown)
{
var existFeatureValues = db.FeatureValues.GetAll().Where(f => f.FeatureId == feature.Id);
if (!String.IsNullOrEmpty(featureValue))
{
var existFeatureValue = existFeatureValues.FirstOrDefault(v => String.Compare(v.Value, featureValue, StringComparison.OrdinalIgnoreCase) == 0);
if (existFeatureValue == null)
{
existFeatureValue = new FeatureValue()
{
FeatureId = feature.Id,
Value = featureValue,
Order = (int)featureValue.ToLower()[0],
};
db.FeatureValues.Add(existFeatureValue);
db.Commit();
}
result = new StyleFeatureValueDTO()
{
FeatureName = featureName,
Value = featureValue,
FeatureId = feature.Id,
FeatureValueId = existFeatureValue.Id,
Type = feature.ValuesType,
};
}
}
if (feature.ValuesType == (int)FeatureValuesType.TextBox)
{
result = new StyleFeatureValueDTO()
{
FeatureName = featureName,
Value = featureValue,
FeatureId = feature.Id,
Type = feature.ValuesType,
};
}
}
else
{
_log.Info("Doesnt exist feature name: " + featureName);
}
return(result);
}
public static void LoadFeatureInformation(Feature feature, InstanceModel model, IEnumerable <Instance> instances, bool fillDatasetInformation = false)
{
if (feature is CategoricalFeature)
{
var len = ((CategoricalFeature)feature).Values.Length;
double[] valuesCount = new double[len];
for (int i = 0; i < len; i++)
{
valuesCount[i] = instances.Count(x => x[feature] == i && !FeatureValue.IsMissing(x[feature]));
}
var valuesmissing = instances.Select(x => x[feature]).Count(FeatureValue.IsMissing);
var valueProbability = valuesCount.Select(x => x / (valuesCount.Sum() * 1.0)).ToArray();
var ratio = valuesCount.Select(x => x / (valuesCount.Min() * 1F)).ToArray();
feature.FeatureInformation = new NominalFeatureInformation()
{
Distribution = valuesCount,
MissingValueCount = valuesmissing,
ValueProbability = valueProbability,
Ratio = ratio,
Feature = feature,
};
}
else if (feature is NumericFeature)
{
var nonMissingValues = instances.Where(x => !FeatureValue.IsMissing(x[feature])).Select(x => x[feature]).ToArray();
var valuesmissing = instances.Count() - nonMissingValues.Length;
double max, min;
if (nonMissingValues.Length > 0)
{
max = nonMissingValues.Max();
min = nonMissingValues.Min();
}
else
{
max = 0;
min = 0;
}
feature.FeatureInformation = new NumericFeatureInformation
{
MissingValueCount = valuesmissing,
MaxValue = max,
MinValue = min,
Feature = feature,
};
}
if (fillDatasetInformation)
{
FillDatasetInformation(model, instances);
}
}
public ActionResult Edit([Bind(Include = "idFeatureValue,featureValue1")] FeatureValue featureValue)
{
if (ModelState.IsValid)
{
db.Entry(featureValue).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(featureValue));
}
public string AddFeatureValue <T>(FeatureValue <T> value)
{
var featureValue = new FeatureValue
{
Type = value.Type.ToString(),
Value = JsonConvert.SerializeObject(value.Value)
};
return(AddFeatureValue(featureValue));
}
public override bool IsMatch(Instance instance)
{
double value = instance[Feature];
if (FeatureValue.IsMissing(value))
{
return(true);
}
return(value == Value);
}
public static FeatureValue GetById(int id)
{
var data = new FeatureValue();
using (ApplicationDbContext db = new ApplicationDbContext())
{
data = db.FeatureValues.FirstOrDefault(x => x.Id == id);
}
return(data);
}
public static FeatureValue Update(FeatureValue model)
{
model.UpdateDate = DateTime.Now;
using (ApplicationDbContext db = new ApplicationDbContext())
{
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
}
return(model);
}
public ActionResult Create([Bind(Include = "idFeatureValue,featureValue1")] FeatureValue featureValue)
{
if (ModelState.IsValid)
{
db.FeatureValues.Add(featureValue);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(featureValue));
}
public void Add(string name, FeatureValue val)
{
if (features.ContainsKey(name))
{
features[name] = val;
}
else
{
features.Add(name, val);
}
}
public static FeatureValue Add(FeatureValue model)
{
model.CreateDate = DateTime.Now;
model.IsDelete = false;
using (ApplicationDbContext db = new ApplicationDbContext())
{
db.FeatureValues.Add(model);
db.SaveChanges();
}
return(model);
}
public double[] Select(Instance instance)
{
if (Feature.FeatureType != FeatureType.Nominal)
{
throw new InvalidOperationException("Cannot use value and complement on non-nominal data");
}
if (FeatureValue.IsMissing(instance[Feature]))
{
return(null);
}
return((int)instance[Feature] == (int)Value ? new double[] { 1, 0 } : new double[] { 0, 1 });
}
public double[] Select(Instance instance)
{
if (Feature.FeatureType == FeatureType.Nominal)
{
throw new InvalidOperationException("Cannot use cutpoint on nominal data");
}
if (FeatureValue.IsMissing(instance[Feature]))
{
return(null);
}
return(instance[Feature] <= CutPoint ? new double[] { 1, 0 } : new double[] { 0, 1 });
}
public Task <int> Create(FeatureValue featureValue)
{
var dbPara = new DynamicParameters();
dbPara.Add("Name", featureValue.Name, DbType.String);
dbPara.Add("Value", featureValue.Value, DbType.String);
var featureValueId = Task.FromResult(_dapperManager.Insert <int>("[dbo].[SP_Add_FeatureValue]",
dbPara,
commandType: CommandType.StoredProcedure));
return(featureValueId);
}
public double[] Select(Instance instance)
{
if (Features.Any(p => p.FeatureType == FeatureType.Nominal))
{
throw new InvalidOperationException("Cannot use cutpoint on nominal data");
}
if (Features.Any(p => FeatureValue.IsMissing(instance[p])))
{
return(null);
}
return(VectorHelper.ScalarProjection(instance, Features, Weights) <= CutPoint ? new double[] { 1, 0 } : new double[] { 0, 1 });
}
public void Initialize(Feature feature, IEnumerable <Tuple <Instance, double> > instances)
{
_instances = instances;
if (Model == null)
{
throw new InvalidOperationException("Model is null");
}
if (ClassFeature.FeatureType != FeatureType.Nominal)
{
throw new InvalidOperationException("Cannot use this iterator on non-nominal class");
}
NominalFeature classFeature = (NominalFeature)ClassFeature;
if (feature.FeatureType != FeatureType.Nominal)
{
throw new InvalidOperationException("Cannot use this iterator on non-nominal feature");
}
_numClasses = classFeature.Values.Length;
_feature = feature;
_perValueDistribution = new Dictionary <double, double[]>();
_totalDistribution = new double[_numClasses];
foreach (var instance in _instances)
{
double value = instance.Item1[feature];
if (FeatureValue.IsMissing(value))
{
continue;
}
double[] current;
if (!_perValueDistribution.TryGetValue(value, out current))
{
_perValueDistribution.Add(value, current = new double[_numClasses]);
}
int classIdx = (int)instance.Item1[ClassFeature];
current[classIdx] += instance.Item2;
_totalDistribution[classIdx] += instance.Item2;
}
CurrentDistribution = new double[2][];
_valuesCount = _perValueDistribution.Count;
existingValues = _perValueDistribution.Keys.ToArray();
_iteratingTwoValues = (_valuesCount == 2);
_valueIndex = -1;
_twoValuesIterated = false;
_initialized = true;
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
FeatureValue featureValue = db.FeatureValues.Find(id);
if (featureValue == null)
{
return(HttpNotFound());
}
return(View(featureValue));
}
public Task <int> Update(FeatureValue featureValue)
{
var dbPara = new DynamicParameters();
dbPara.Add("Id", featureValue.ID);
dbPara.Add("Name", featureValue.Name, DbType.String);
dbPara.Add("Value", featureValue.Value, DbType.String);
var updateFeatureValue = Task.FromResult(_dapperManager.Update <int>("[dbo].[SP_Update_FeatureValue]",
dbPara,
commandType: CommandType.StoredProcedure));
return(updateFeatureValue);
}
public void btnDelete_Click(object sender, RoutedEventArgs e)
{
FeatureValue feature = (lvMain.SelectedItem as FeatureValue);
if (feature == null)
{
return;
}
if (MessageBox.Show("Are you sure you want to delete this feature?", "Delete feature?", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes)
{
List.Remove(feature);
}
}
public IList <FeatureValue> Aggregate(
IList <EncounterValues> values, RawRecord record,
FeatureGroup featureGroup, FeatureSelectionContext context)
{
var result = new FeatureValue[values[0].Values.Count];
for (var i = 0; i < result.Length; i++)
{
result[i] = new FeatureValue(
string.Join("__", values.Select(x => x.Values[i].StringValue)));
}
return(result);
}
public FeatureValues(IFeature Feature, FeatureValue[] Values)
{
this.Feature = Feature;
this.Values = Values;
}
/// <summary>
/// ファイル名から特徴量を出す処理
/// </summary>
/// <param name="file_name"></param>
public void MakeFeatureFromIpl(IplImage ipl_image, int face_id)
{
string eye_cascade_xml = @"C:\opencv2.4.10\sources\data\haarcascades\haarcascade_eye.xml";
string nose_cascade_xml = @"C:\opencv2.4.10\sources\data\haarcascades\haarcascade_mcs_nose.xml";
string mouth_cascade_xml = @"C:\opencv2.4.10\sources\data\haarcascades\haarcascade_mcs_mouth.xml";
CvMemStorage strage = new CvMemStorage(0); // メモリを確保
CvHaarClassifierCascade eye_cascade = CvHaarClassifierCascade.FromFile(eye_cascade_xml);
CvHaarClassifierCascade nose_cascade = CvHaarClassifierCascade.FromFile(nose_cascade_xml);
CvHaarClassifierCascade mouth_cascade = CvHaarClassifierCascade.FromFile(mouth_cascade_xml);
//リストにあるファイルを一枚づつデータにする
{
IplImage tmp_image;
//サイズが小さければ拡大して使う
if (ipl_image.Size.Width < SMALL_IMAGE_LIMIT)
{
tmp_image = Cv.CreateImage(new CvSize(ipl_image.Width * IMAGE_RESIZE_RATE, ipl_image.Height * IMAGE_RESIZE_RATE), BitDepth.U8, 3);
Cv.Resize(ipl_image, tmp_image);
}
else
{
tmp_image = Cv.CreateImage(new CvSize(ipl_image.Width, ipl_image.Height), BitDepth.U8, 3);
Cv.Resize(ipl_image, tmp_image);
}
//グレースケールに変換
IplImage gray_image = Cv.CreateImage(new CvSize(tmp_image.Width, tmp_image.Height), BitDepth.U8, 1);
Cv.CvtColor(tmp_image, gray_image, ColorConversion.BgrToGray);
//発見した矩形
this.EyeResult = Cv.HaarDetectObjects(gray_image, eye_cascade, strage);
//鼻は画像の真ん中の方だけ
{
IplImage gray_nose_image = Cv.CreateImage(new CvSize(tmp_image.Width, tmp_image.Height), BitDepth.U8, 1);
Cv.CvtColor(tmp_image, gray_nose_image, ColorConversion.BgrToGray);
CvRect rect = new CvRect(0, (int)(tmp_image.Height*0.25), tmp_image.Width, tmp_image.Height / 2);
gray_nose_image.ROI = rect;
// new CvWindow(gray_nose_image);
// Cv.WaitKey();
this.NoseResult = Cv.HaarDetectObjects(gray_nose_image, nose_cascade, strage);
}
//口は画像の下半分だけを調べる
{
IplImage gray_mouth_image = Cv.CreateImage(new CvSize(tmp_image.Width, tmp_image.Height), BitDepth.U8, 1);
Cv.CvtColor(tmp_image, gray_mouth_image, ColorConversion.BgrToGray);
CvRect rect = new CvRect(0, (int)(tmp_image.Height *0.66), tmp_image.Width, tmp_image.Height / 3);
gray_mouth_image.ROI = rect;
// new CvWindow(gray_mouth_image);
// Cv.WaitKey();
this.MouthResult = Cv.HaarDetectObjects(gray_mouth_image, mouth_cascade, strage);
}
//初期化
DataInit();
//デバッグ用の表示
// DebugPrint(tmp_image, this.ReadCount);
//左眼、右目、鼻、口の矩形を確定させる。
DecidePartsRect(gray_image);
//パーツ確定後
// DebugPrint2(gray_image, this.ReadCount);
PartsRectInfo parts_info;
parts_info.RightEye = this.RightEyeRect;
parts_info.LeftEye = this.LeftEyeRect;
parts_info.Nose = this.NoseRect;
parts_info.Mouth = this.MouthRect;
//特徴量を作る
FeatureValue feature_value = new FeatureValue();
bool ret = MakeFeatureValue(gray_image, ref parts_info, out feature_value);
//正しいデータを登録
if (ret)
{
feature_value.ID = face_id;
this.FeatuerValueList.Add(feature_value);
}
}
//メモリ解放
eye_cascade.Dispose();
nose_cascade.Dispose();
mouth_cascade.Dispose();
strage.Dispose();
return;
}
/// <summary>
/// 特徴量をだす
/// </summary>
private bool MakeFeatureValue(IplImage img, ref PartsRectInfo input_info, out FeatureValue output_info)
{
//仮に代入
output_info.basepoint = new CvPoint(0, 0);
output_info.BothEyeDistance = 0;
output_info.LeftEyeValueL = 0;
output_info.LeftEyeValueR = 0;
output_info.RightEyeValueL = 0;
output_info.RightEyeValueR = 0;
output_info.NoseLValueL = 0;
output_info.NoseLValueR = 0;
output_info.MouthLValueL = 0;
output_info.MouthLValueR = 0;
output_info.ID = 0;
//パーツがすべてそろっているかの確認
if (input_info.RightEye.X == 0)
{
return false;
}
if (input_info.LeftEye.X == 0)
{
return false;
}
if (input_info.Nose.X == 0)
{
return false;
}
if (input_info.Mouth.X == 0)
{
return false;
}
//瞳の間の場所を基点として各パーツとの比率をとる
//（パーツ座標と基点との距離）/瞳の間の距離を学習データとする
int LeftEyeCenterX = input_info.LeftEye.X + input_info.LeftEye.Width / 2;
int LeftEyeCenterY = input_info.LeftEye.Y + input_info.LeftEye.Height / 2;
int RightEyeCenterX = input_info.RightEye.X + input_info.RightEye.Width / 2;
int RightEyeCenterY = input_info.RightEye.Y + input_info.RightEye.Height / 2;
//右目の中心と左目の中心を結んだ線の中点が基準点。
output_info.basepoint.X = (LeftEyeCenterX + RightEyeCenterX) / 2;
output_info.basepoint.Y = (LeftEyeCenterY + RightEyeCenterY) / 2;
//目と目の距離をとる
output_info.BothEyeDistance = makeTwoPointDistance(LeftEyeCenterX, RightEyeCenterX, LeftEyeCenterY, RightEyeCenterY);
//基準点から各パーツの右端、左端までの距離をとる
output_info.LeftEyeValueL = makeTwoPointDistance(input_info.LeftEye.X,
output_info.basepoint.X,
input_info.LeftEye.Y,
output_info.basepoint.Y);
output_info.LeftEyeValueR = makeTwoPointDistance(input_info.LeftEye.X + input_info.LeftEye.Width,
output_info.basepoint.X,
input_info.LeftEye.Y,
output_info.basepoint.Y);
output_info.RightEyeValueL = makeTwoPointDistance(input_info.RightEye.X,
output_info.basepoint.X,
input_info.RightEye.Y,
output_info.basepoint.Y);
output_info.RightEyeValueR = makeTwoPointDistance(input_info.RightEye.X + input_info.RightEye.Width,
output_info.basepoint.X,
input_info.RightEye.Y,
output_info.basepoint.Y);
output_info.NoseLValueL = makeTwoPointDistance(input_info.Nose.X,
output_info.basepoint.X,
input_info.Nose.Y,
output_info.basepoint.Y);
output_info.NoseLValueR = makeTwoPointDistance(input_info.Nose.X + input_info.Nose.Width,
output_info.basepoint.X,
input_info.Nose.Y,
output_info.basepoint.Y);
output_info.MouthLValueL = makeTwoPointDistance(input_info.Mouth.X,
output_info.basepoint.X,
input_info.Mouth.Y,
output_info.basepoint.Y);
output_info.MouthLValueR = makeTwoPointDistance(input_info.Mouth.X + input_info.Mouth.Width,
output_info.basepoint.X,
input_info.Mouth.Y,
output_info.basepoint.Y);
//基準点からパーツまでの距離と瞳間距離の比率を特徴量とする
output_info.LeftEyeValueL /= output_info.BothEyeDistance;
output_info.LeftEyeValueR /= output_info.BothEyeDistance;
output_info.RightEyeValueL /= output_info.BothEyeDistance;
output_info.RightEyeValueR /= output_info.BothEyeDistance;
output_info.NoseLValueL /= output_info.BothEyeDistance;
output_info.NoseLValueR /= output_info.BothEyeDistance;
output_info.MouthLValueL /= output_info.BothEyeDistance;
output_info.MouthLValueR /= output_info.BothEyeDistance;
return true;
}
/// <summary>
/// Updates values.
/// </summary>
/// <param name="value">
/// The given feature value.
/// </param>
/// <exception cref="ArgumentNullException">
/// Exception.
/// </exception>
/// <exception cref="InvalidDataException">
/// Exception.
/// </exception>
public void Update(FeatureValue value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (value.ValueType != FeatureValueType.FEATURE_VALUE_TYPE_UNKOWN)
{
if (value.ValueType == FeatureValueType.FEATURE_VALUE_TYPE_STRING)
{
throw new InvalidDataException("Cannot support string type linguistic feature");
}
if (!Values.Contains(value.IntValue))
{
Values.Add(value.IntValue);
}
}
}
public LocalNativeRecord(MgReader reader, FixedWKTReader mgReader, MgAgfReaderWriter agfRw, MgWktReaderWriter wktRw)
{
for (int i = 0; i < reader.GetPropertyCount(); i++)
{
string name = reader.GetPropertyName(i);
_ordinalMap[i] = name;
var pt = (PropertyValueType)reader.GetPropertyType(name);
switch (pt)
{
case PropertyValueType.Blob:
_values[name] = new BlobValue();
break;
case PropertyValueType.Boolean:
_values[name] = new BooleanValue();
break;
case PropertyValueType.Byte:
_values[name] = new ByteValue();
break;
case PropertyValueType.Clob:
_values[name] = new ClobValue();
break;
case PropertyValueType.DateTime:
_values[name] = new DateTimeValue();
break;
case PropertyValueType.Double:
_values[name] = new DoubleValue();
break;
case PropertyValueType.Feature:
_values[name] = new FeatureValue();
break;
case PropertyValueType.Geometry:
_values[name] = new GeometryValue();
break;
case PropertyValueType.Int16:
_values[name] = new Int16Value();
break;
case PropertyValueType.Int32:
_values[name] = new Int32Value();
break;
case PropertyValueType.Int64:
_values[name] = new Int64Value();
break;
case PropertyValueType.Raster:
_values[name] = new RasterValue();
break;
case PropertyValueType.Single:
_values[name] = new SingleValue();
break;
case PropertyValueType.String:
_values[name] = new StringValue();
break;
}
}
for (int i = 0; i < reader.GetPropertyCount(); i++)
{
string name = _ordinalMap[i];
GetByteReaderMethod getblob = () => { return reader.GetBLOB(name); };
GetByteReaderMethod getclob = () => { return reader.GetCLOB(name); };
GetByteReaderMethod getgeom = () => { return reader.GetGeometry(name); };
if (!reader.IsNull(name))
{
var pt = (PropertyValueType)reader.GetPropertyType(name);
switch (pt)
{
case PropertyValueType.Blob:
((BlobValue)_values[name]).Value = Utility.StreamAsArray(new MgReadOnlyStream(getblob));
break;
case PropertyValueType.Boolean:
((BooleanValue)_values[name]).Value = reader.GetBoolean(name);
break;
case PropertyValueType.Byte:
((ByteValue)_values[name]).Value = reader.GetByte(name);
break;
case PropertyValueType.Clob:
byte [] b = Utility.StreamAsArray(new MgReadOnlyStream(getclob));
((ClobValue)_values[name]).Value = Encoding.UTF8.GetChars(b);
break;
case PropertyValueType.DateTime:
((DateTimeValue)_values[name]).Value = Utility.ConvertMgDateTime(reader.GetDateTime(name));
break;
case PropertyValueType.Double:
((DoubleValue)_values[name]).Value = reader.GetDouble(name);
break;
//case PropertyValueType.Feature:
case PropertyValueType.Geometry:
try
{
//TODO: See if SWIG issues come into play here
var geom = agfRw.Read(reader.GetGeometry(name));
var wkt = wktRw.Write(geom);
((GeometryValue)_values[name]).Value = mgReader.Read(wkt);
}
catch //Invalid geometry fail!
{
((GeometryValue)_values[name]).SetNull();
}
break;
case PropertyValueType.Int16:
((Int16Value)_values[name]).Value = reader.GetInt16(name);
break;
case PropertyValueType.Int32:
((Int32Value)_values[name]).Value = reader.GetInt32(name);
break;
case PropertyValueType.Int64:
((Int64Value)_values[name]).Value = reader.GetInt64(name);
break;
case PropertyValueType.Single:
((SingleValue)_values[name]).Value = reader.GetSingle(name);
break;
case PropertyValueType.String:
((StringValue)_values[name]).Value = reader.GetString(name);
break;
}
}
}
}
private int ParseLine(string line, out string featureName, out Operator op,
out FeatureValue threshold, out TextClass textClass, out List<double> classDist)
{
featureName = null;
op = Operator.Unknown;
threshold = null;
textClass = TextClass.Unknown;
classDist = null;
if (line.StartsWith("#") || String.IsNullOrEmpty(line))
return -1;
int level = line.Split(new char[] { '|' }, StringSplitOptions.None).Length;
Match m = nodeRegex.Match(line);
if (m.Success == true)
{
featureName = m.Result("${feature}");
string opStr = m.Result("${op}");
if (opStr == ">")
op = Operator.G;
else if (opStr == ">=")
op = Operator.GE;
else if (opStr == "<")
op = Operator.L;
else if (opStr == "<=")
op = Operator.LE;
else if (opStr == "=")
op = Operator.E;
else if (opStr == "!=")
op = Operator.NE;
else
op = Operator.Unknown;
string strThreshold = m.Result("${threshold}");
double numThreshold = 0.0;
if (Double.TryParse(strThreshold, out numThreshold))
threshold = new FeatureValue(numThreshold);
else
threshold = new FeatureValue(strThreshold);
string strClass = m.Result("${class}");
if (strClass.Length > 0)
{
int intTextClass = Convert.ToInt32(strClass);
if ((intTextClass > 5) || (intTextClass < 0))
textClass = TextClass.Unknown;
else
textClass = (TextClass)Math.Pow(2, intTextClass);
}
else
textClass = TextClass.Unknown;
string distribution = m.Result("${distribution}");
if (distribution.Length > 0)
{
classDist = new List<double>();
foreach (string cd in distribution.Split(new char[1] { '/' }))
classDist.Add(Double.Parse(cd));
}
}
return level;
}
public Node(Node parent, string featureName, Operator op, FeatureValue threshold)
: this(parent, featureName, op, threshold, TextClass.Unknown, null)
{
}
public Node(Node parent, string featureName, Operator op, FeatureValue threshold, TextClass textClass, List<double> classDist)
{
this.parent = parent;
this.featureName = featureName;
this.op = op;
this.threshold = threshold;
this.textClass = textClass;
this.classDist = classDist;
}
public XmlRecord(XmlProperty[] properties, FixedWKTReader wktReader, XmlNodeList propertyNodes, string nameElement, string valueElement)
{
for (int i = 0; i < properties.Length; i++)
{
string name = properties[i].Name;
_ordinalMap[i] = name;
switch (properties[i].Type)
{
case PropertyValueType.Blob:
_values[name] = new BlobValue();
break;
case PropertyValueType.Boolean:
_values[name] = new BooleanValue();
break;
case PropertyValueType.Byte:
_values[name] = new ByteValue();
break;
case PropertyValueType.Clob:
_values[name] = new ClobValue();
break;
case PropertyValueType.DateTime:
_values[name] = new DateTimeValue();
break;
case PropertyValueType.Double:
_values[name] = new DoubleValue();
break;
case PropertyValueType.Feature:
_values[name] = new FeatureValue();
break;
case PropertyValueType.Geometry:
_values[name] = new GeometryValue();
break;
case PropertyValueType.Int16:
_values[name] = new Int16Value();
break;
case PropertyValueType.Int32:
_values[name] = new Int32Value();
break;
case PropertyValueType.Int64:
_values[name] = new Int64Value();
break;
case PropertyValueType.Raster:
_values[name] = new RasterValue();
break;
case PropertyValueType.Single:
_values[name] = new SingleValue();
break;
case PropertyValueType.String:
_values[name] = new StringValue();
break;
}
}
foreach (XmlNode propNode in propertyNodes)
{
var name = propNode[nameElement].InnerText;
var valueNode = propNode[valueElement];
if (valueNode != null)
{
var value = valueNode.InnerText;
switch (_values[name].Type)
{
case PropertyValueType.Blob:
((BlobValue)_values[name]).Value = Encoding.UTF8.GetBytes(value);
break;
case PropertyValueType.Boolean:
((BooleanValue)_values[name]).Value = XmlConvert.ToBoolean(value);
break;
case PropertyValueType.Byte:
((ByteValue)_values[name]).Value = XmlConvert.ToByte(value);
break;
case PropertyValueType.Clob:
((ClobValue)_values[name]).Value = value.ToCharArray();
break;
case PropertyValueType.DateTime:
var dt = ConvertToDateTime(value);
if (dt.HasValue)
((DateTimeValue)_values[name]).Value = dt.Value;
break;
case PropertyValueType.Double:
((DoubleValue)_values[name]).Value = XmlConvert.ToDouble(value);
break;
case PropertyValueType.Feature:
((FeatureValue)_values[name]).Value = ConvertToFeatures(value);
break;
case PropertyValueType.Geometry:
((GeometryValue)_values[name]).Value = wktReader.Read(value);
break;
case PropertyValueType.Int16:
((Int16Value)_values[name]).Value = XmlConvert.ToInt16(value);
break;
case PropertyValueType.Int32:
((Int32Value)_values[name]).Value = XmlConvert.ToInt32(value);
break;
case PropertyValueType.Int64:
((Int64Value)_values[name]).Value = XmlConvert.ToInt64(value);
break;
case PropertyValueType.Raster:
((RasterValue)_values[name]).Value = ConvertToRaster(value);
break;
case PropertyValueType.Single:
((SingleValue)_values[name]).Value = XmlConvert.ToSingle(value);
break;
case PropertyValueType.String:
((StringValue)_values[name]).Value = value;
break;
}
}
}
}
public void Add(string name, FeatureValue val)
{
if (features.ContainsKey(name))
features[name] = val;
else
features.Add(name, val);
}
