public static bool Cmp(CmpType cmp, int lv, int rv)
{
switch (cmp)
{
case CmpType.lt:
{
return(lv < rv);
}
case CmpType.le:
{
return(lv <= rv);
}
case CmpType.eq:
{
return(lv == rv);
}
case CmpType.ge:
{
return(lv >= rv);
}
case CmpType.gt:
{
return(lv > rv);
}
}
return(false);
}
public static bool Cmp(CmpType cmp, int lv, int rv)
{
switch (cmp)
{
case CmpType.lt:
{
return lv < rv;
}
case CmpType.le:
{
return lv <= rv;
}
case CmpType.eq:
{
return lv == rv;
}
case CmpType.ge:
{
return lv >= rv;
}
case CmpType.gt:
{
return lv > rv;
}
}
return false;
}
public void SetParams(int intA, int intB)
{
type = CmpType.Int;
this.intA = intA;
this.intB = intB;
strA = strB = null;
floatA = floatB = 0f;
}
public void SetParams(float floatA, float floatB)
{
type = CmpType.Float;
this.floatA = floatA;
this.floatB = floatB;
strA = strB = null;
intA = intB = 0;
}
public CmpEnemyNum(CmpType cmp, int num)
{
_cmp = cmp;
_num = num;
}
public CmpTeammateNum(CmpType cmp, int num)
{
_cmp = cmp;
_num = num;
}
public CmpEnemyHP(CmpType cmp, int percent)
{
_cmp = cmp;
_percent = percent;
}
public CmpSelfHP(CmpType cmp, int percent)
{
_cmp = cmp;
_percent = percent;
}
public CmpRate(CmpType cmp, int rate)
{
_cmp = cmp;
_rate = rate;
}
private Image <Gray, byte> CreateMaskOfOverInappropriateColorProportions(Image <Gray, byte> grayImage, Image <Bgr, byte> image, double tone, BgrColor color, CmpType cmpType, double margin)
{
double interval = 0;
float count = (image?.CountNonzero()[(int)color]) ?? 1;
float nonZeroCount;
Image <Gray, byte> resultMask = grayImage.CopyBlank();
switch (cmpType)
{
case CmpType.LessThan: { interval = Math.Round((1 - margin) * tone, 3); } break;
case CmpType.GreaterThan: { interval = Math.Round((1 + margin) * tone, 3); } break;
default: { interval = tone; } break;
}
using (Image <Gray, byte> model = grayImage.Mul(interval * 3.0))
{
using (Image <Gray, byte> cmpImage = _image[(int)color].Cmp(model[0], cmpType))
{
using (Image <Gray, byte> disColorMask = cmpImage.ThresholdBinary(new Gray(1), new Gray(255)))
{
Mat kernel = CvInvoke.GetStructuringElement(ElementShape.Ellipse, new Size(3, 3), new Point(-1, -1));
CvInvoke.MorphologyEx(disColorMask, resultMask, MorphOp.Open, kernel, new Point(-1, -1), 1, BorderType.Replicate, new MCvScalar(1.0));
nonZeroCount = resultMask[0]?.CountNonzero()[0] ?? 0;
}
}
}
if (nonZeroCount / count > 0.20 && margin < 1.0)
{
margin += 0.05;
return(CreateMaskOfOverInappropriateColorProportions(grayImage, image, tone, color, cmpType, margin));
}
else
{
return(resultMask);
}
}
public CmpTargetDistance(CmpType cmp, int distance)
{
_cmp = cmp;
_distance = distance;
}
public CmpLastSkillCoord(CmpType cmp, int distance)
{
_cmp = cmp;
_distance = distance;
}
public CmpSkillUseCount(int skillId, CmpType cmp, int useCount)
{
_skillId = skillId;
_cmp = cmp;
_useCount = useCount;
}
public CmpEnemyNum(CmpType cmp, int num)
{
_cmp = cmp;
_num = num;
}
public CmpTeammateNum(CmpType cmp, int num)
{
_cmp = cmp;
_num = num;
}
public CmpEnemyHP(CmpType cmp, int percent)
{
_cmp = cmp;
_percent = percent;
}
public CmpSelfHP(CmpType cmp, int percent)
{
_cmp = cmp;
_percent = percent;
}
public CmpSkillUseCount(int skillId, CmpType cmp, int useCount)
{
_skillId = skillId;
_cmp = cmp;
_useCount = useCount;
}
public CmpLastSkillCoord(CmpType cmp, int distance)
{
_cmp = cmp;
_distance = distance;
}
public CmpTargetDistance(CmpType cmp, int distance)
{
_cmp = cmp;
_distance = distance;
}
private void RepairColor(ref Image <Bgr, byte> cleanedImage, Image <Gray, byte> grayImage, Image <Gray, byte> generalImageMask, BgrColor bgrColor, double colorTone, CmpType cmpType)
{
using (Image <Gray, byte> defectsMask = CreateMaskOfOverInappropriateColorProportions(grayImage, cleanedImage /*_image*/, colorTone, bgrColor, cmpType, _margin))
{
using (Image <Gray, byte> repairMask = generalImageMask.Mul(defectsMask))
{
Image <Bgr, byte> cleanedPatchImage = cleanedImage.CopyBlank();
cleanedPatchImage[0] = cleanedImage[(int)bgrColor].Mul(BlueTone * 3);
cleanedPatchImage[1] = cleanedImage[(int)bgrColor].Mul(GreenTone * 3);
cleanedPatchImage[2] = cleanedImage[(int)bgrColor].Mul(RedTone * 3);
cleanedImage = MorphologicalProcessing.CombineTwoImages(cleanedImage, cleanedPatchImage, repairMask);
}
}
}
/// <summary>
/// Moves to the next item in the current scope (skips over subitems of the current item). Returns
/// false if there are no more items in the current scope.
/// </summary>
/// <returns>True if an item is selected after the operation.</returns>
public bool NextItem()
{
// If we are currently pointing at the beginning of a group, we need to skip past it.
if (currentItemType == CmpType.Group)
{
// Do this by opening (half-assedly) the group, then closing it
cursorPos++;
currentLevel++;
CloseItem();
}
// Selection will be empty unless we find something
UnselectItem();
// Grab item name. If we didn't find an item name, set itemSelected to false.
SkipWhitespace();
if (cursorPos < document.Length)
{
currentItemName = GrabIdentifier();
}
itemSelected = currentItemName != null;
if (itemSelected)
{
SkipWhitespace(); // Move to value
if (cursorPos >= document.Length)
{
throw new CmpDocumentException("Item does not have a value.");
}
if (document[cursorPos] == '"')
{
// string
cursorPos++;
var startOfString = cursorPos;
SkipPastString();
var strLen = cursorPos - startOfString - 1;
currentItemValue = document.Substring(startOfString, strLen);
currentItemType = CmpType.String;
}
else if (document[cursorPos] == '(')
{
// Group
currentItemType = CmpType.Group;
}
else
{
// Unquoted string ("Literal")
var value = GrabLiteral();
if (value == null)
{
throw new CmpDocumentException("Item does not have a value.");
}
currentItemValue = value;
currentItemType = CmpType.Literal;
}
}
else
{
// If we didn't find an item, one of the following is true
// - We are at the end of a group (a closing paren must be present)
// - We are at the end of the document (cursor points past last char)
// - There is a syntax error
if (cursorPos < document.Length)
{
if (document[cursorPos] != ')')
{
throw new CmpDocumentException("Unexpected text in document at position " + cursorPos.ToString());
}
}
else
{
// If we reached the end of the document and there is a group that wasn't closed, that's an error
if (currentLevel > 0)
{
ErrEndOfDoc();
}
}
}
return(itemSelected);
}
public CmpRate(CmpType cmp, int rate)
{
_cmp = cmp;
_rate = rate;
}
private void UnselectItem()
{
currentItemName = currentItemValue = null;
currentItemType = CmpType.None;
itemSelected = false;
}
public void SetType(CmpType type)
{
this.type = type;
}
/// <summary>
///
/// </summary>
/// <param name="isFirst">是否第一个查询条件，如果true，则忽略CompositeType</param>
/// <returns></returns>
public string Parse(bool isFirst = false)
{
//条件模板：and/or ag.gp_name like '%asdfasd%'
string sql = string.Format(" {0} {1} ", (isFirst || CmpType == CompositeType.None) ? "" : CmpType.ToString(), Field);
switch (ConditionType)
{
//字符串
case ConditionType.Contain:
sql += string.Format("{0} like '%{1}%'", Not ? "not" : "", (string)Value);
break;
case ConditionType.StartWith:
sql += string.Format("{0} like '{1}%'", Not ? "not" : "", (string)Value);
break;
case ConditionType.EndWith:
sql += string.Format("{0} like '%{1}'", Not ? "not" : "", (string)Value);
break;
case ConditionType.GreaterThan:
sql += ParseNumberAndDateTime(ConditionType.GreaterThan);
break;
case ConditionType.GreaterOrEqual:
sql += ParseNumberAndDateTime(ConditionType.GreaterOrEqual);
break;
case ConditionType.LessThan:
sql += ParseNumberAndDateTime(ConditionType.LessThan);
break;
case ConditionType.LessOrEqual:
sql += ParseNumberAndDateTime(ConditionType.LessOrEqual);
break;
case ConditionType.Equal:
sql += string.Format("{0} {1}", Not ? "<>" : "=", FieldType == FieldType.Number ? (string)Value : ("'" + (string)Value + "'"));
break;
case ConditionType.In:
sql += ParseIn();
break;
case ConditionType.IsEmpty:
sql += string.Format("is {0} null", Not ? "not" : "");
break;
case ConditionType.Between:
sql += ParseBetween();
break;
}
return(sql);
}
