Пример #1
0
        /// <summary>
        /// Расчет инсоляции в файле
        /// </summary>
        public void Calc()
        {
            var docIns = InsCompare.GetDocumentOrOpen(calcFile);
            var dbIns  = docIns.Database;

            // Очистка инс объектов
            InsCompare.GetInsObjects(calcFile, a =>
            {
                a.UpgradeOpen();
                a.Erase();
                Debug.WriteLine($"Erase - {a}");
            });

            using (docIns.LockDocument())
                using (var t = dbIns.TransactionManager.StartTransaction())
                {
                    //InsService
                    var insModel = InsModel.LoadIns(docIns);
                    insModel.Tree.IsVisualTreeOn   = true;
                    insModel.Tree.IsVisualIllumsOn = true;
                    insModel.Front.Groups?.ToList().ForEach(g => g.IsVisualFrontOn = true);
                    insModel.Place.Places?.ToList().ForEach(p => p.IsVisualPlaceOn = true);
                    insModel.Place.IsEnableCalc = true;

                    insModel.Update(docIns);

                    // Визуализация на чертеже всех расчетов
                    insModel.Tree.DrawVisuals();
                    insModel.Front.DrawVisuals();
                    insModel.Place.DrawVisuals();

                    t.Commit();
                }
        }
Пример #2
0
        /// <summary>
        /// Поиск модели для документа
        /// </summary>
        /// <param name="doc">Документ или null, тогда текущий док)</param>
        /// <returns></returns>
        private static InsModel GetInsModel(Document doc)
        {
            if (doc == null || doc.IsDisposed)
            {
                return(null);
            }
            InsModel res = null;

            insModels?.TryGetValue(doc, out res);
            return(res);
        }
Пример #3
0
        /// <summary>
        /// Расчет фронтонов дома
        /// </summary>
        public List <FrontValue> CalcHouse(House house, out List <List <FrontCalcPoint> > contourSegmentsCalcPoints)
        {
            contourSegmentsCalcPoints = new List <List <FrontCalcPoint> >();
            if (house == null)
            {
                return(null);
            }

            var resFronts = new List <FrontValue>();

            this.house = house;
            front      = house.FrontGroup?.Front;
            if (front == null)
            {
                return(resFronts);
            }
            frontOpt = front.Options;
            model    = front.Model;
            map      = model.Map;
            delta    = frontOpt.StepCalcPointInFront;

            var houseContour = house.Contour;

            // Расчет фронтов на каждом сегменте контура дома
            for (int i = 0; i < houseContour.NumberOfVertices; i++)
            {
                try
                {
                    using (var seg = houseContour.GetLineSegment2dAt(i))
                    {
                        List <FrontCalcPoint> segCalcPoints;
                        var segFronts = CalcSegment(seg, out segCalcPoints);
                        if (segFronts != null && segFronts.Any())
                        {
                            resFronts.AddRange(segFronts);
                        }
                        contourSegmentsCalcPoints.Add(segCalcPoints);
                    }
                }
                catch (Exception ex) // houseContour.GetLineSegment2dAt(i) - если сегмент не линейный
                {
                    Logger.Log.Error(ex, "CalcFrontCentral.CalcHouse");
                }
            }
            //resFronts = FrontValue.Merge(resFronts);
            return(resFronts);
        }
Пример #4
0
        /// <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);
        }
Пример #5
0
        /// <summary>
        /// Включение отключение расчета для текущего документа
        /// </summary>
        /// <param name="onOff">Включение или выключение расчета</param>
        private static void ActivateIns(bool onOff)
        {
            Inspector.Clear();
            var doc = Application.DocumentManager.MdiActiveDocument;

            if (insViewModel == null)
            {
                return;
            }

            if (doc == null || doc.IsDisposed)
            {
                insViewModel.Model = null;
                return;
            }

            var insModel = GetInsModel(doc);

            // Включение расчета для текущего документа
            if (onOff)
            {
                if (insModel == null)
                {
                    // Новый расчет
                    // Загрузка сохраненного расчета в чертеже (если он есть)
                    insModel = InsModel.LoadIns(doc);
                    if (insModel == null)
                    {
                        // Создание нового расчета
                        insModel = new InsModel();
                    }
                    insModels.Add(doc, insModel);
                    // Инициализация расчета
                    //insModel.Initialize(doc);
                    //insModel.Map.UpdateVisual();// Т.к. расчет не обновляется, то визуализация домов на карте (без отдельной визуализации домов во фронтах.)

                    // Не обновлять расчет - пусть вручную обновляют
                    //try
                    //{
                    //    insModel.Update();
                    //}
                    //catch(UserBreakException)
                    //{
                    //}
                    // лог включения инсоляции для текущего чертежа
                    Logger.Log.Info($"Включение расчета инсоляции для чертежа - {doc.Name}");
                }
                //else
                //{
                //    insModel.Initialize(doc);
                //    insModel.UpdateVisual();
                //}
                insModel.IsEnabled = true;
                insModel.Update();
            }
            // Отключение расчета для текущего документа
            else
            {
                if (insModel != null)
                {
                    insModel.ClearVisual(); // Очистка визуализаций
                    insModel.IsEnabled = false;
                    // лог отключения инсоляции для текущего чертежа
                    Logger.Log.Info($"Отключение расчета инсоляции для чертежа - {doc.Name}");
                }
            }
            // Переключение на модель (или на null)
            insViewModel.Model = insModel;
            Inspector.Show();
        }
Пример #6
0
        public ActionResult Insert(InsModel model)
        {
            var    values = Request.Form;
            string Id;

            if (model.Mark != null)
            {
                Marks mark = new Marks();
                if (db.Marks.Count() > 0)
                {
                    Id      = db.Marks.Max(m => m.Id);
                    mark.Id = IDtostr(Int32.Parse(Id) + 1);
                }
                else
                {
                    mark.Id = "0001";
                }
                mark.Mark = model.Mark;
                if (ValidMark(mark))
                {
                    db.Marks.Add(mark);
                    db.SaveChanges();
                    ViewBag.VMark = "Марка вставленна";
                }
                else
                {
                    ViewBag.VMark = "Неправильный формат данных";
                }
            }
            if (model.Modell != null)
            {
                Models.Models _model = new Models.Models();
                if (db.Models.Count() > 0)
                {
                    Id        = db.Models.Max(m => m.Id);
                    _model.Id = IDtostr(Int32.Parse(Id) + 1);
                }
                else
                {
                    _model.Id = "0001";
                }
                _model.Model   = model.Modell;
                _model.IdMark  = model.IdMark;
                _model.Picture = model.Picture;
                if (ValidModel(_model))
                {
                    db.Models.Add(_model);
                    db.SaveChanges();
                    ViewBag.VModel = "Модель вставлена";
                }
                else
                {
                    ViewBag.VModel = "Неправильный формат данных";
                }
            }
            if (model.Modification != null)
            {
                Modifications modification = new Modifications();
                if (db.Modifications.Count() > 0)
                {
                    Id = db.Modifications.Max(m => m.Id);
                    modification.Id = IDtostr(Int32.Parse(Id) + 1);
                }
                else
                {
                    modification.Id = "0001";
                }
                modification.IdMark       = model.IdMark;
                modification.IdModel      = model.IdModel;
                modification.Modification = model.Modification;
                modification.Peng         = model.Peng;
                modification.Price        = model.Price;
                modification.Privod       = model.Privod;
                modification.Veng         = model.Veng;
                modification.Amount       = model.Amount;
                if (ModelState.IsValid)
                {
                    db.Modifications.Add(modification);
                    db.SaveChanges();
                    ViewBag.VModification = "Модификация вставлена";
                }
                else
                {
                    ViewBag.VModification = "Неправильный формат данных";
                }
            }
            var MarkLst   = new List <Marks>();
            var ModelLst  = new List <Models.Models>();
            var MarkQuery = from d in db.Marks
                            orderby d.Mark
                            select d;
            var ModelQuery = from d in db.Models
                             orderby d.Model
                             select d;

            MarkLst.AddRange(MarkQuery.Distinct());
            ModelLst.AddRange(ModelQuery.Distinct());
            ViewBag.MarkLst  = MarkLst;
            ViewBag.ModelLst = ModelLst;
            return(View());
        }