public InsPointViewModel(InsPoint insPoint, bool isSinglePointEdit = true)
{
IsSinglePointEdit = isSinglePointEdit;
BuildingTypes = new ObservableCollection <BuildingTypeEnum> {
BuildingTypeEnum.Living, BuildingTypeEnum.Social
};
InsPoint = insPoint;
// Точка не на здании, а в свободном месте (типа расчета площадки), окна - нет!
if (insPoint.Building == null)
{
HasBuilding = false;
WindowVM = new WindowOptionsViewModel(null);
}
else
{
HasBuilding = true;
build = insPoint.Building.Building;
BuildingType = insPoint.Building.BuildingType;
if (WindowOptions.Default == insPoint.Window)
{
WindowVM = new WindowOptionsViewModel(defaultWindow);
}
else
{
WindowVM = new WindowOptionsViewModel(insPoint.Window);
}
}
Height = insPoint.Height;
OK = new RelayCommand(OnOkExecute);
}
private List <Polyline> GetTreePolylines(InsPoint insPoint, List <VisualOption> visOptions)
{
var plsPointTrees = new List <Polyline>();
if (insPoint.AngleStartOnPlane == 0 && insPoint.AngleEndOnPlane == 0)
{
return(plsPointTrees);
}
Point2d p1 = insPoint.Point.Convert2d();
Point2d p2 = p1;
Point2d p3;
Point2d p4;
var treeVisOptions = insPoint.Model.Tree.TreeOptions.TreeVisualOptions;
for (int i = 0; i < treeVisOptions.Count; i++)
{
var pl = GetPolylineTreeOption(insPoint, treeVisOptions[i], visOptions[i], p1, p2, out p3, out p4);
p1 = p4;
p2 = p3;
plsPointTrees.Add(pl);
}
return(plsPointTrees);
}
/// <summary>
/// Графика визуализации заданной высотности (настройка визуализации елочек)
/// </summary>
/// <param name="insPoint">инс точка</param>
/// <param name="treeOpt">Настройка визуализации высоты улочек</param>
/// <param name="p1">Первая точка елочки (левый верхний угол прямоугольника). Для первой елочки p1=p2=insPoint</param>
/// <param name="p2">Правый верхний угол елочки</param>
/// <param name="p3">Нижний правый угол елочки (возвращается)</param>
/// <param name="p4">Нижений левый угол елочки (возвращается)</param>
/// <returns></returns>
private Polyline GetPolylineTreeOption(InsPoint insPoint, TreeVisualOption treeOpt, VisualOption visOpt,
Point2d p1, Point2d p2, out Point2d p3, out Point2d p4)
{
var ptOrig = insPoint.Point.Convert2d();
var calcValues = TreeModel.Model.CalcService.CalcValues;
double cShadow;
// Высота тени (на заданной настройкой высоте елочки) - катет по Y
var yShadow = calcValues.YShadowLineByHeight(treeOpt.Height, out cShadow);
// Луч падения - катет по X до точки на луче, на заданой высоте
var xRay = calcValues.GetXRay(yShadow, insPoint.AngleStartOnPlane);
p3 = ptOrig + new Vector2d(xRay, -yShadow);
xRay = calcValues.GetXRay(yShadow, insPoint.AngleEndOnPlane);
p4 = ptOrig + new Vector2d(xRay, -yShadow);
var points = new List <Point2d> {
p1, p2, p3, p4
};
var pl = CreatePolyline(points, visOpt);
return(pl);
}
/// <summary>
/// Расчет инсоляции в точке
/// </summary>
public List <IIlluminationArea> CalcPoint(InsPoint insPoint, bool withOwnerBuilding = true)
{
if (HostApplicationServices.Current.UserBreak())
{
throw new UserBreakException();
}
var illumAreas = new List <IIlluminationArea>();
if (withOwnerBuilding && insPoint.Building == null)
{
return(illumAreas);
}
var doc = insPoint.Model.Doc;
using (var calcPt = new CalcPointCentral(insPoint, insService))
{
calcPt.WithOwnerBuilding = withOwnerBuilding;
// Расчет освещенности в точке
illumAreas = calcPt.Calc();
insPoint.AngleStartOnPlane = calcPt.StartAnglesIllum.AngleStartOnPlane;
insPoint.AngleEndOnPlane = calcPt.StartAnglesIllum.AngleEndOnPlane;
}
return(illumAreas);
}
private void OnShowPointExecute(InsPoint insPt)
{
if ((short)Application.GetSystemVariable("TILEMODE") == 0)
{
return;
}
Tree.ShowPoint(insPt);
}
///// <summary>
///// Начальный угол в плане (радиан). Начальное значение = 0 - восход.
///// Будут определены для этой расвчетной точки индивидуально
///// </summary>
//public double AngleStartOnPlane { get; private set; }
///// <summary>
///// Конечный угол в плане (радиан). Начальное значение = 180 - заход
///// </summary>
//public double AngleEndOnPlane { get; private set; }
public CalcPointCentral(InsPoint insPt, CalcServiceCentral insCalcService)
{
this.map = insPt.Model.Map;
buildingOwner = insPt.Building;
this.insPt = insPt;
ptCalc = insPt.Point;
ptCalc2d = ptCalc.Convert2d();
this.calc = insCalcService;
values = insCalcService.CalcValues;
//AngleStartOnPlane = values.SunCalcAngleStartOnPlane;
//AngleEndOnPlane = values.SunCalcAngleEndOnPlane;
StartAnglesIllum = new IllumAreaBase(insPt, ptCalc2d, values.SunCalcAngleStartOnPlane, values.SunCalcAngleEndOnPlane,
Point2d.Origin, Point2d.Origin);
}
private void OnEditPointExecute(InsPoint insPoint)
{
var building = insPoint?.Building;
//if (building == null) return;
var oldBuildingType = building?.BuildingType ?? Elements.Buildings.BuildingTypeEnum.Living;
var selectedPoints = Tree.Points.Where(w => w.IsSelected).ToList();
var insPointVM = new InsPointViewModel(insPoint, selectedPoints.Count == 1);
//var uiVisualizerService = ServiceLocator.Default.ResolveType<IUIVisualizerService>();
if (InsService.ShowDialog(insPointVM) != true)
{
return;
}
// Если измениля тип здания - то пересчет всех точек на этом здании
if (building != null && oldBuildingType != building.BuildingType)
{
//// Учет изменения типа здания для всех точек на этом здании
Tree.Model.ChangeBuildingType(building);
}
else
{
if (selectedPoints.Count > 1)
{
selectedPoints.Remove(insPoint);
foreach (var selPt in selectedPoints)
{
selPt.Height = insPoint.Height;
if (insPoint.Window != null)
{
selPt.Window = insPoint.Window;
}
selPt.Update();
}
}
// Обновление точки
insPoint.Update();
}
// Обновление елочек
Tree.UpdateVisualTree(insPoint);
// Сохранение точки в словарь
insPoint.SaveInsPoint();
}
/// <summary>
/// Расчет площадки
/// </summary>
public List <Tile> CalcPlace(Place place)
{
List <Tile> tiles;
dictLevels = new Dictionary <double, TileLevel>();
placeOptions = place.PlaceModel.Options;
levels = placeOptions.Levels.OrderByDescending(o => o.TotalTimeMin).ToList();
model = place.PlaceModel.Model;
step = placeOptions.TileSize;
stepHalf = step * 0.5;
stepQuart = step * 0.25;
using (pl = place.PlaceId.Open(OpenMode.ForRead) as Polyline)
{
place.Area = NetLib.DoubleExt.Round(pl.Area, 2);
// Нарезка площадки на ячейки (tiles)
tiles = DividePlace();
// расчет каждой ячейке (точка - без оуна и без здания)
var insPt = new InsPoint();
insPt.Model = model;
insPt.Window = null;
insPt.Building = null;
insPt.Height = 0;
foreach (var tile in tiles)
{
insPt.Point = tile.Point.Convert3d();
try
{
var illums = calcTrees.CalcPoint(insPt, false);
tile.InsValue = calcService.CalcTimeAndGetRate(illums, Elements.Buildings.BuildingTypeEnum.Living);
tile.Level = DefineLevel(tile.InsValue.TotalTime);
}
catch (UserBreakException)
{
throw;
}
catch
{
tile.InsValue = InsValue.Empty;
tile.Level = TileLevel.Empty;
// На угловых точках - может не рассчитаться пока
// Пропустить!?
}
}
}
return(tiles);
}
private void InsAddPointExecute()
{
try
{
// Выбор точки на чертеже и задание параметров окна
var selPt = new SelectPoint();
InsPoint p = selPt.SelectNewPoint(Tree.Model);
if (p != null)
{
// Расчет и добавление точки
Tree.AddPoint(p);
// Включение зон инсоляции точки
p.IsVisualIllumsOn = true;
// Сохранение точки
p.SaveInsPoint();
// Запись статистики
PluginStatisticsHelper.AddStatistic();
}
}
catch (Exception ex)
{
InsService.ShowMessage(ex, "Ошибка");
}
}
public VisualPointIllums(InsPoint insPoint) : base("ins_sapr_angle")
{
InsPoint = insPoint;
}
/// <summary>
/// Определение расчетных точек на сегменте
/// </summary>
private List <FrontCalcPoint> CalcFrontPoints(LineSegment2d seg, double delta)
{
var calcPts = new List <FrontCalcPoint>();
calcPts.Add(new FrontCalcPoint(seg.StartPoint, true));
// Добавление остальных точек с заданным шагом от стартовой до конечной
var countSteps = Convert.ToInt32(seg.Length / delta) - 1;
if (countSteps == 0)
{
// Добавление средней точки сегмента
calcPts.Add(new FrontCalcPoint(seg.MidPoint, false));
}
else
{
var ptPrew = seg.StartPoint;
var vecDelta = seg.Direction * delta;
for (int i = 0; i < countSteps; i++)
{
var ptNext = ptPrew + vecDelta;
calcPts.Add(new FrontCalcPoint(ptNext, false));
ptPrew = ptNext;
}
}
calcPts.Add(new FrontCalcPoint(seg.EndPoint, true));
// Определение блок-секций для точек
DefineSectionInRange(ref calcPts);
// Расчетные точки с определенными секциями - только их считать
//calcPts = calcPts.Where(w => w.Section != null).ToList();
// Расчет в точке
var insPt = new InsPoint();
insPt.Model = model;
insPt.Window = house.GetCalcFrontWindow();
foreach (var calcFrontPt in calcPts)
{
if (calcFrontPt.Section == null)
{
continue;
}
if (calcFrontPt.IsCorner)
{
calcFrontPt.IsCalulated = true;
continue;
}
insPt.Point = calcFrontPt.Point.Convert3d();
#if TEST
//EntityHelper.AddEntityToCurrentSpace(new DBPoint(insPt.Point));
#endif
insPt.Building = calcFrontPt.Section;
// Уточнение высоты расчета фронта с учетом параметров заданных в здании (Section) - если не задана общая высота для фронта пользователем
insPt.Height = CalcHeightCalcPt(calcFrontPt);
insPt.Building.InitContour();
using (insPt.Building.Contour)
{
try
{
var illums = calcTrees.CalcPoint(insPt);
var insValue = calcService.CalcTimeAndGetRate(illums, calcFrontPt.Section.BuildingType);
calcFrontPt.InsValue = insValue.Requirement.Type;
calcFrontPt.IsCalulated = true;
}
catch (UserBreakException)
{
throw;
}
catch
{
calcFrontPt.InsValue = InsRequirementEnum.None;
calcFrontPt.IsCorner = true;
// На угловых точках - может не рассчитаться пока
// Пропустить!?
}
}
}
return(calcPts);
}
private void OnDeletePointExecute(InsPoint insPoint)
{
insPoint.Delete();
}
