//=============================
public GeoBlockMultiLayer(GeoReader reader, int geoX, int geoY, bool l2j) : base(geoX, geoY)
{
_cells3D = new GeoCell[GeoEngine.GEO_BLOCK_SHIFT, GeoEngine.GEO_BLOCK_SHIFT][];
//
int layers, count = 0;
for (int x = 0; x < GeoEngine.GEO_BLOCK_SHIFT; x++)
{
for (int y = 0; y < GeoEngine.GEO_BLOCK_SHIFT; y++)
{
layers = l2j ? reader.get() : reader.getShort();
if (!GeoEngine.layersValid(layers))
{
throw new Exception("Invalid layer count " + layers);
}
//
count += layers;
_cells3D[x, y] = new GeoCell[layers];
for (int i = layers; i-- > 0;)
{
_cells3D[x, y][i] = new GeoCellCM(this, reader.getShort(), x, y);
}
//Util.quickSort(_cells3D[x,y], HeightComparator.Compare);
}
}
//
copyCells(count);
calcMaxMinHeight();
}
private IEnumerable <GeoModel> createBlock(GeoBlock block)
{
float ox, oy, oz;
if (block.getType() == GEO.GEO_BLOCK_TYPE_FLAT)
{
GeoCell cell = block.nGetCell(0, 0, 0);
//
float xx = GEO.getWorldX(cell.getGeoX());
float yy = GEO.getWorldY(cell.getGeoY());
float zz = GEO.getHeight(cell.getHeight());
yield return(appendModel(xx, zz, yy, true));
}
else if (block.getType() == GEO.GEO_BLOCK_TYPE_COMPLEX)
{
GeoModel m;
GeoCell cell;
GeoCell[] cells = block.getCells();
int c = cells.Length;
for (int i = 0; i < c; i++)
{
cell = cells[i];
ox = GEO.getWorldX(cell.getGeoX());
oz = GEO.getWorldY(cell.getGeoY());
oy = GEO.getHeight(cell.getHeight());
m = appendModel(ox, oy, oz, false);
updateMask(m, cell);
yield return(m);
}
}
else if (block.getType() == GEO.GEO_BLOCK_TYPE_MULTILAYER)
{
int c = block.getMaxLayerCount();
//
GeoModel m;
int x, y;
int min_x = block.getGeoX();
int max_x = block.getMaxGeoX();
int min_y = block.getGeoY();
int max_y = block.getMaxGeoY();
for (y = min_y; y <= max_y; y++)
{
for (x = min_x; x <= max_x; x++)
{
GeoCell[] cells = block.nGetLayers(x, y);
foreach (GeoCell cell in cells)
{
ox = GEO.getWorldX(cell.getGeoX());
oz = GEO.getWorldY(cell.getGeoY());
oy = GEO.getHeight(cell.getHeight());
m = appendModel(ox, oy, oz, false);
updateMask(m, cell);
yield return(m);
}
}
}
}
}
//-----------------------------
public void setSelectedGeoCell(GeoCell cell)
{
_selectedCell = cell;
//
if (!_waitForUpdate)
{
_waitForUpdate = true;
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => { onSelectedCellUpdated(); }));
}
}
public override GeoCell[] nGetLayers(int geoX, int geoY)
{
int cellX = GeoEngine.getCellXY(geoX);
int cellY = GeoEngine.getCellXY(geoY);
GeoCell[] layers = _cells3D[cellX, cellY];
GeoCell[] result = new GeoCell[layers.Length];
Array.Copy(layers, result, layers.Length);
return(result);
}
public void calcMaxMinHeight()
{
short minHeight = short.MaxValue, maxHeight = short.MinValue;
for (int x = 0, y; x < GeoEngine.GEO_BLOCK_SHIFT; x++)
{
for (y = 0; y < GeoEngine.GEO_BLOCK_SHIFT; y++)
{
GeoCell cell = _cells[indexOf(x, y)];
minHeight = Math.Min(cell.getHeight(), minHeight);
maxHeight = Math.Max(cell.getHeight(), maxHeight);
}
}
_minHeight = minHeight;
_maxHeight = maxHeight;
}
private GeoBlockMultiLayer(GeoBlockComplex block) : base(block.getGeoX(), block.getGeoY())
{
_cells3D = new GeoCell[GeoEngine.GEO_BLOCK_SHIFT, GeoEngine.GEO_BLOCK_SHIFT][];
_cells = new GeoCell[GeoEngine.GEO_BLOCK_SHIFT * GeoEngine.GEO_BLOCK_SHIFT];
for (int x = 0; x < GeoEngine.GEO_BLOCK_SHIFT; x++)
{
for (int y = 0; y < GeoEngine.GEO_BLOCK_SHIFT; y++)
{
GeoCell cell = new GeoCellCM(this, block.nGetCellByLayer(x, y, 0).getHeightAndNSWE(), x, y);
_cells3D[x, y] = new GeoCell[1];
_cells3D[x, y][0] = cell;
_cells[x * GeoEngine.GEO_BLOCK_SHIFT + y] = cell;
}
}
calcMaxMinHeight();
}
private void updateMask(GeoModel model, GeoCell cell)
{
short nswe = cell.getNSWE();
if ((nswe & GEO.NSWE_ALL) == GEO.NSWE_ALL)
{
model.Mask = Vector4.Zero;
}
else
{
model.Mask.X = ((nswe & GEO.NORTH) == GEO.NORTH ? 0f : 1f);
model.Mask.Y = ((nswe & GEO.EAST) == GEO.EAST ? 0f : 1f);
model.Mask.Z = ((nswe & GEO.SOUTH) == GEO.SOUTH ? 0f : 1f);
model.Mask.W = ((nswe & GEO.WEST) == GEO.WEST ? 0f : 1f);
}
}
private GeoBlockMultiLayer(GeoBlockFlat block) : base(block.getGeoX(), block.getGeoY())
{
_cells3D = new GeoCell[GeoEngine.GEO_BLOCK_SHIFT, GeoEngine.GEO_BLOCK_SHIFT][];
_cells = new GeoCell[GeoEngine.GEO_BLOCK_SHIFT * GeoEngine.GEO_BLOCK_SHIFT];
//
for (int x = 0; x < GeoEngine.GEO_BLOCK_SHIFT; x++)
{
for (int y = 0; y < GeoEngine.GEO_BLOCK_SHIFT; y++)
{
GeoCell cell = new GeoCellCM(this, GeoEngine.convertHeightToHeightAndNSWEALL(block.getMinHeight()), x, y);
_cells3D[x, y] = new GeoCell[1];
_cells3D[x, y][0] = cell;
_cells[x * GeoEngine.GEO_BLOCK_SHIFT + y] = cell;
}
}
calcMaxMinHeight();
}
//public bool isInside(GeoCell cell) {
// if (_geoX == int.MinValue) return false;
// if (cell.getBlock().getGeoX() != _geoX) return false;
// if (cell.getBlock().getGeoY() != _geoY) return false;
// if (_infHeight) return true;
// //
// int height = cell.getHeight();
// if (height < _geoZ - _height || height > _geoZ + _height) return false;
// return true;
//}
public void getAllCellsInside(GeoCell reference, GeoCell[] cells, FastArrayList <GeoCell> store)
{
if (_infHeight)
{
store.addAll(cells);
}
else
{
int height;
int geoZ = reference.getHeight();
foreach (GeoCell cell in cells)
{
height = cell.getHeight();
if (height >= geoZ - _height && height <= geoZ + _height)
{
store.add(cell);
}
}
}
}
private GeoBlockMultiLayer(GeoBlockMultiLayer block) : base(block.getGeoX(), block.getGeoY())
{
_cells3D = new GeoCell[GeoEngine.GEO_BLOCK_SHIFT, GeoEngine.GEO_BLOCK_SHIFT][];
//
int layers, count = 0;
for (int x = 0; x < GeoEngine.GEO_BLOCK_SHIFT; x++)
{
for (int y = 0; y < GeoEngine.GEO_BLOCK_SHIFT; y++)
{
layers = block.nGetLayerCount(x, y);
count += layers;
_cells3D[x, y] = new GeoCell[layers];
while (layers-- > 0)
{
GeoCell cell = new GeoCellCM(this, block.nGetCellByLayer(x, y, layers).getHeightAndNSWE(), x, y);
_cells3D[x, y][layers] = cell;
}
}
}
//
copyCells(count);
calcMaxMinHeight();
}
private void SiteCol_SiteModifyEvent(object sender, NESiteEventArgs e)
{
if (sender.ToString() != "GIS")
{
GeoSiteEventArgs args = new GeoSiteEventArgs();
foreach (Site site in e.Site)
{
GeoSite geoNESite = Site.GetGeoNESite(site);
args.SiteList.Add(geoNESite);
List<Transceiver> tranceiversOfSite = this.m_TranceiverCol.GetTranceiversOfSite(site);
List<Transceiver> list2 = new List<Transceiver>();
foreach (Transceiver transceiver in tranceiversOfSite)
{
list2.Add(transceiver);
}
foreach (Transceiver transceiver2 in list2)
{
transceiver2.X = site.X + transceiver2.DeltaX;
transceiver2.Y = site.Y + transceiver2.DeltaY;
GeoCell item = new GeoCell();
item = Transceiver.GetGeoNECell(transceiver2);
args.TranceiverList.Add(item);
}
}
args.argSender = sender;
if (this.m_GeoMsgChange != null)
{
this.m_GeoMsgChange.ModifySiteMsgChange(args);
this.m_GeoMsgChange.MapRedraw();
}
}
}
public static GeoCell GetGeoNECell(Transceiver transceiver)
{
GeoCell cell2 = new GeoCell();
cell2.ID = transceiver.ID;
cell2.Name = transceiver.Name;
cell2.Active = transceiver.Active;
cell2.Visible = transceiver.Visible;
return cell2;
}
public bool isSelectedGeoCell(GeoCell cell)
{
return(_selectedCell == cell);
}
public static int Compare(GeoCell cell_1, GeoCell cell_2)
{
return(cell_1.getHeight().CompareTo(cell_2.getHeight()));
}
public Transceiver GetLTETranceiver(GeoCell cell)
{
return ServiceHelper.Lookup<IGeoNEDeal>(this.m_AppContext).GeoTranceiverById(cell.ID);
}
public override void updateLayerFor(GeoCell cell)
{
}
public override void updateLayerFor(GeoCell cell)
{
Util.quickSort(_cells3D[cell.getCellX(), cell.getCellY()], HeightComparator.Compare);
}
