forked from andkok/MWS_2021
290 lines
11 KiB
C#
290 lines
11 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
|
|
namespace ConsoleLSystem {
|
|
public class LSystemNodeLiteralVariable : LSystemNodeLiteral {
|
|
public Dictionary<string, int> variableIndex { get; }
|
|
|
|
public LSystemNodeLiteralVariable(string name, int values_number, Dictionary<string, int> variableIndex) : base(name, values_number) {
|
|
this.variableIndex = variableIndex;
|
|
}
|
|
|
|
}
|
|
public class LSystemNodeGenerator : LSystemNode {
|
|
MathExpression[] math_expressions;
|
|
|
|
public LSystemNodeGenerator(string name, int arguments) : base(new LSystemNodeLiteral(name, arguments)) {
|
|
}
|
|
public void fillArguments(MathExpression[] math_expressions) {
|
|
this.math_expressions = math_expressions;
|
|
}
|
|
public LSystemNode eval(float[] values) {
|
|
var literal = new LSystemNodeLiteral(this.literal.name, this.literal.values_number);
|
|
for (int i = 0; i < literal.values_number; i++) {
|
|
literal.values[i] = math_expressions[i].eval(values);
|
|
}
|
|
var result = new LSystemNode(literal);
|
|
foreach (LSystemNodeGenerator child in children) {
|
|
var _child = child.eval(values);
|
|
_child.parent = result;
|
|
result.children.Add(_child);
|
|
|
|
}
|
|
if (mainChild != null) {
|
|
var _mainChild = ((LSystemNodeGenerator)mainChild).eval(values);
|
|
_mainChild.parent = result;
|
|
result.mainChild = _mainChild;
|
|
}
|
|
else {
|
|
result.mainChild = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
}
|
|
abstract public class LSystemRule {
|
|
abstract public bool is_aplicable(LSystemNode processed_node);
|
|
abstract public LSystemNode rewrite(LSystemNode processed_node);
|
|
}
|
|
|
|
public class LSystemRuleBasic : LSystemRule {
|
|
LSystemNodeLiteral input;// { get; }
|
|
LSystemNode output;
|
|
|
|
public LSystemRuleBasic(LSystemNodeLiteral input, LSystemNode output) {
|
|
this.input = input;
|
|
this.output = output;
|
|
}
|
|
|
|
override public bool is_aplicable(LSystemNode processed_node) {
|
|
if (processed_node.literal == input) {
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
override public LSystemNode rewrite(LSystemNode processed_node) {
|
|
if (is_aplicable(processed_node)) {
|
|
return output.deep_copy();
|
|
}
|
|
else {
|
|
return new LSystemNode(processed_node.literal);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LSystemRuleParametric : LSystemRule {
|
|
LSystemNodeLiteralVariable predecesor;// { get; }
|
|
LSystemNodeGenerator consequent;
|
|
MathExpressionComparison[] conditions;
|
|
|
|
public LSystemRuleParametric(LSystemNodeLiteralVariable predecesor, MathExpressionComparison[] conditions, LSystemNodeGenerator consequent) {
|
|
this.predecesor = predecesor;
|
|
this.consequent = consequent;
|
|
this.conditions = conditions;
|
|
}
|
|
|
|
public override bool is_aplicable(LSystemNode processed_node) {
|
|
if (processed_node.literal.name != predecesor.name || processed_node.literal.values_number != predecesor.values_number) {
|
|
return false;
|
|
}
|
|
foreach (var condition in conditions) {
|
|
if (!condition.eval(processed_node.literal.values)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override LSystemNode rewrite(LSystemNode processed_node) {
|
|
if (is_aplicable(processed_node)) {
|
|
return consequent.eval(processed_node.literal.values);
|
|
}
|
|
else {
|
|
return new LSystemNode(processed_node.literal);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LSystemRuleParametricStochastic : LSystemRule {
|
|
protected LSystemNodeLiteralVariable predecesor;// { get; }
|
|
protected LSystemNodeGenerator[] consequents;
|
|
protected float[] probabilities;
|
|
protected MathExpressionComparison[] conditions;
|
|
protected Random random;
|
|
|
|
public LSystemRuleParametricStochastic(LSystemNodeLiteralVariable predecesor, MathExpressionComparison[] conditions, LSystemNodeGenerator[] consequents, float[] probabilities) {
|
|
this.predecesor = predecesor;
|
|
this.consequents = consequents;
|
|
this.conditions = conditions;
|
|
float probabilities_sum = 0;
|
|
foreach (var probability in probabilities) { probabilities_sum += probability; }
|
|
float acumulator = 0;
|
|
this.probabilities = new float[consequents.Length];
|
|
for (int i = 0; i < consequents.Length; i++) {
|
|
var probability = probabilities[i] / probabilities_sum;
|
|
this.probabilities[i] = probability + acumulator;
|
|
acumulator += probability;
|
|
}
|
|
random = new Random();
|
|
|
|
}
|
|
public LSystemRuleParametricStochastic(LSystemNodeLiteralVariable predecesor, MathExpressionComparison[] conditions, LSystemNodeGenerator consequent) {
|
|
this.predecesor = predecesor;
|
|
this.consequents = new LSystemNodeGenerator[] { consequent };
|
|
this.conditions = conditions;
|
|
float probabilities_sum = 0;
|
|
probabilities = new float[1] { 1 };
|
|
random = new Random();
|
|
|
|
}
|
|
public override bool is_aplicable(LSystemNode processed_node) {
|
|
if (processed_node.literal.name != predecesor.name || processed_node.literal.values_number != predecesor.values_number) {
|
|
return false;
|
|
}
|
|
foreach (var condition in conditions) {
|
|
if (!condition.eval(processed_node.literal.values)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override LSystemNode rewrite(LSystemNode processed_node) {
|
|
var result = random.NextDouble();
|
|
int consequent_index = 0;
|
|
for (int i = 0; i < probabilities.Length; i++) {
|
|
if (result < probabilities[i]) {
|
|
consequent_index = i;
|
|
break;
|
|
}
|
|
}
|
|
if (is_aplicable(processed_node)) {
|
|
return consequents[consequent_index].eval(processed_node.literal.values);
|
|
}
|
|
else {
|
|
return new LSystemNode(processed_node.literal);
|
|
}
|
|
}
|
|
}
|
|
public class LSystemContext {
|
|
public LSystemNodeLiteral parent { get; set; }
|
|
public LSystemNodeLiteral child { get; set; }
|
|
public LSystemNodeLiteral mid { get; set; }
|
|
bool isPreceding = false;
|
|
bool isSucceeding = false;
|
|
|
|
public LSystemContext(LSystemNodeLiteral parent, LSystemNodeLiteral child) {
|
|
this.parent = parent;
|
|
this.child = child;
|
|
this.isPreceding = true;
|
|
this.isSucceeding = true;
|
|
}
|
|
public LSystemContext() {
|
|
|
|
}
|
|
public void setOnlyPreceding(LSystemNodeLiteral parent) {
|
|
this.parent = parent;
|
|
this.mid = mid;
|
|
this.isPreceding = true;
|
|
this.isSucceeding = false;
|
|
}
|
|
public void setOnlySucceeding(LSystemNodeLiteral child) {
|
|
this.child = child;
|
|
this.isPreceding = false;
|
|
this.isSucceeding = true;
|
|
}
|
|
public bool isAplicable(LSystemNode node,out float[] variables) {
|
|
var variables_list = new List<float>();
|
|
if (isPreceding && parent != node.parent.literal) {
|
|
variables = new float[0];
|
|
return false;
|
|
}
|
|
if (isPreceding) {
|
|
variables_list.AddRange(node.parent.literal.values);
|
|
}
|
|
variables_list.AddRange(node.literal.values);
|
|
if (isSucceeding) {
|
|
var result = false;
|
|
LSystemNodeLiteral childLiteral;
|
|
foreach(var child in node.getAllChildren()) {
|
|
if (child.literal == this.child) {
|
|
childLiteral = child.literal;
|
|
result = true;
|
|
variables_list.AddRange(child.literal.values);
|
|
break;
|
|
}
|
|
}
|
|
if (!result) {
|
|
variables = new float[0];
|
|
return false;
|
|
}
|
|
}
|
|
variables = variables_list.ToArray();
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public class LSystemRuleParametricStochasticContext : LSystemRuleParametricStochastic {
|
|
LSystemContext context;
|
|
public LSystemRuleParametricStochasticContext(LSystemNodeLiteralVariable predecesor, MathExpressionComparison[] conditions, LSystemNodeGenerator[] consequents, float[] probabilities, LSystemContext context) : base(predecesor, conditions, consequents, probabilities) {
|
|
this.context = context;
|
|
}
|
|
public LSystemRuleParametricStochasticContext(LSystemNodeLiteralVariable predecesor, MathExpressionComparison[] conditions, LSystemNodeGenerator consequent, LSystemContext context) : base(predecesor, conditions, consequent) {
|
|
this.context = context;
|
|
}
|
|
public override bool is_aplicable(LSystemNode processed_node) {
|
|
if (processed_node.literal.name != predecesor.name || processed_node.literal.values_number != predecesor.values_number) {
|
|
return false;
|
|
}
|
|
var variables = new float[0];
|
|
if (!context.isAplicable(processed_node, out variables)) {
|
|
return false;
|
|
}
|
|
foreach (var condition in conditions) {
|
|
if (!condition.eval(variables)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
bool is_aplicable(LSystemNode processed_node, out float[] variables) {
|
|
variables = new float[0];
|
|
if (processed_node.literal.name != predecesor.name || processed_node.literal.values_number != predecesor.values_number) {
|
|
return false;
|
|
}
|
|
if (!context.isAplicable(processed_node, out variables)) {
|
|
return false;
|
|
}
|
|
foreach (var condition in conditions) {
|
|
if (!condition.eval(variables)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override LSystemNode rewrite(LSystemNode processed_node) {
|
|
var result = random.NextDouble();
|
|
int consequent_index = 0;
|
|
for (int i = 0; i < probabilities.Length; i++) {
|
|
if (result < probabilities[i]) {
|
|
consequent_index = i;
|
|
}
|
|
}
|
|
float[] variables;
|
|
if (is_aplicable(processed_node, out variables)) {
|
|
return consequents[consequent_index].eval(variables);
|
|
}
|
|
else {
|
|
return new LSystemNode(processed_node.literal);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|