//---------------------------------------------------------------------
// Count Cache
async Task <int> IGrainDCacheMapCounter.countMap()
{
ListCountTask.Clear();
for (int i = 1; i <= MapCount; i++)
{
SB.Clear();
SB.Append(KeyTitle);
SB.Append("_");
SB.Append(i);
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
ListCountTask.Add(grain_map.getMapCount());
}
await Task.WhenAll(ListCountTask);
MapCacheDataCount = 0;
foreach (var i in ListCountTask)
{
if (i.IsCompleted)
{
MapCacheDataCount += ((Task <int>)i).Result;
}
}
ListCountTask.Clear();
return(MapCacheDataCount);
}
//---------------------------------------------------------------------
// 初始化MasteSlave
async Task IGrainDCache.initMasteSlave(string maste_name)
{
var grain_master = this.GrainFactory.GetGrain <IGrainDCacheMaster>(maste_name);
bool is_inited = await grain_master.GetIfInit();
if (is_inited)
{
return;
}
grain_master.Init();
grain_master.setup(maste_name, DCacheMasterSlaveMaxDeep, DCacheMasterSlaveCount);
for (int i = 1; i <= DCacheMasterSlaveCount; i++)
{
SB.Clear();
SB.Append(maste_name);
SB.Append("_");
SB.Append(SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(SLAVE_ROOT_DEEP);
SB.Append("_");
SB.Append(i);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
grain_slave.setup(maste_name, SLAVE_ROOT_DEEP, DCacheMasterSlaveMaxDeep, DCacheMasterSlaveCount);
}
}
//---------------------------------------------------------------------
// Count 所有MapCache
async Task <int> IGrainDCache.countMap(string map_name)
{
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(DCACHEMAP_COUNTER_TITLE);
var grain_mapcounter = this.GrainFactory.GetGrain <IGrainDCacheMapCounter>(SB.ToString());
int count = await grain_mapcounter.countMap();
return(count);
}
//---------------------------------------------------------------------
// 从Map中随机获取数据
async Task <List <byte[]> > IGrainDCache.getFromMapRandom(string map_name, int count)
{
int map_index = Random.Next(1, DCacheMapCount + 1);
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(map_index);
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
var list_value = await grain_map.getFromMapRandom(count);
return(list_value);
}
//---------------------------------------------------------------------
public override Task OnDeactivateAsync()
{
if (Random != null)
{
Random = null;
}
if (SB != null)
{
SB.Clear();
SB = null;
}
return(base.OnDeactivateAsync());
}
//---------------------------------------------------------------------
public override Task OnDeactivateAsync()
{
if (SB != null)
{
SB.Clear();
SB = null;
}
if (ListCountTask != null)
{
ListCountTask.Clear();
ListCountTask = null;
}
return(base.OnDeactivateAsync());
}
//---------------------------------------------------------------------
public override Task OnDeactivateAsync()
{
if (MapCache != null)
{
MapCache.Clear();
MapCache = null;
}
if (SB != null)
{
SB.Clear();
SB = null;
}
return(base.OnDeactivateAsync());
}
//---------------------------------------------------------------------
// add数据到Map中
async Task <string> IGrainDCache.addToMap(string map_name, string ticket, string key, byte[] value)
{
if (string.IsNullOrEmpty(ticket))
{
int map_index = Random.Next(1, DCacheMapCount + 1);
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(map_index);
ticket = SB.ToString();
}
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(ticket);
var tick = await grain_map.addToMap(key, value);
return(tick);
}
//---------------------------------------------------------------------
// 从MasteSlave中获取数据
async Task <byte[]> IGrainDCache.getFromMasteSlave(string maste_name, string key)
{
int slave_count = (int)Math.Pow(DCacheMasterSlaveCount, DCacheMasterSlaveMaxDeep - 1);
int slave_index = Random.Next(1, slave_count + 1);
SB.Clear();
SB.Append(maste_name);
SB.Append("_");
SB.Append(SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(DCacheMasterSlaveMaxDeep);
SB.Append("_");
SB.Append(slave_index);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
var result = await grain_slave.getFromSlave(key);
return(result);
}
//---------------------------------------------------------------------
// add数据到MasteSlave中
Task IGrainDCacheMaster.addToMasteSlave(string key, byte[] value)
{
MapCache[key] = value;
for (int i = 1; i <= SlaveCount; i++)
{
SB.Clear();
SB.Append(MasterName);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_ROOT_DEEP);
SB.Append("_");
SB.Append(i);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
grain_slave.addToSlave(key, value);
}
return(TaskDone.Done);
}
//---------------------------------------------------------------------
// remove数据
Task IGrainDCacheMaster.removeFromMasteSlave(string key)
{
if (MapCache.ContainsKey(key))
{
MapCache.Remove(key);
}
for (int i = 1; i <= SlaveCount; i++)
{
SB.Clear();
SB.Append(MasterName);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_MAP_NAME);
SB.Append("_");
SB.Append(GrainDCache.SLAVE_ROOT_DEEP);
SB.Append("_");
SB.Append(i);
var grain_slave = this.GrainFactory.GetGrain <IGrainDCacheSlave>(SB.ToString());
grain_slave.removeFromSlave(key);
}
return(TaskDone.Done);
}
//---------------------------------------------------------------------
// 初始化Map
async Task IGrainDCache.initMap(string map_name)
{
int count = DCacheMapCount;
int map_index = Random.Next(1, count + 1);
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(map_index);
var grain_maprandom = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
var is_inited = await grain_maprandom.GetIfInit();
if (is_inited)
{
return;
}
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(DCACHEMAP_COUNTER_TITLE);
var grain_mapcounter = this.GrainFactory.GetGrain <IGrainDCacheMapCounter>(SB.ToString());
grain_mapcounter.setup(map_name, count);
for (int i = 1; i <= count; i++)
{
SB.Clear();
SB.Append(map_name);
SB.Append("_");
SB.Append(i);
var grain_map = this.GrainFactory.GetGrain <IGrainDCacheMap>(SB.ToString());
grain_map.setup();
}
}
private int method5(List <double[][]>[] rgbList, int chr)
{
List <double> subDiff = new List <double>();
List <double[][]> MR, MG, MB;
List <double[][]> SR, SG, SB;
int listSize = rgbList[0].Count;
int windowSize = Math.Min(Global.maxWidth, listSize);
int result = 0;
int minWidth = 40;
switch (chr)
{
case 0:
// 4:4:4
for (int i = minWidth; i < windowSize; i++)
{
MR = rgbList[0].Take(listSize - i).ToList();
MG = rgbList[1].Take(listSize - i).ToList();
MB = rgbList[2].Take(listSize - i).ToList();
SR = rgbList[0].Skip(i).ToList();
SG = rgbList[1].Skip(i).ToList();
SB = rgbList[2].Skip(i).ToList();
subDiff.Add(UBDiffSum(MR, MG, MB, SR, SG, SB));
MR.Clear();
MG.Clear();
MB.Clear();
SR.Clear();
SG.Clear();
SB.Clear();
}
result = subDiff.IndexOf(subDiff.Min()) + minWidth;
break;
case 1:
// 4:4:0
for (int i = minWidth; i < windowSize; i++)
{
MR = rgbList[0].Where((item, index) => index % 2 != 0).Take(listSize / 2 - i).ToList();
MG = rgbList[1].Where((item, index) => index % 2 != 0).Take(listSize / 2 - i).ToList();
MB = rgbList[2].Where((item, index) => index % 2 != 0).Take(listSize / 2 - i).ToList();
SR = rgbList[0].Skip(2 * i).Where((item, index) => index % 2 == 0).ToList();
SG = rgbList[1].Skip(2 * i).Where((item, index) => index % 2 == 0).ToList();
SB = rgbList[2].Skip(2 * i).Where((item, index) => index % 2 == 0).ToList();
subDiff.Add(UBDiffSum(MR, MG, MB, SR, SG, SB));
MR.Clear();
MG.Clear();
MB.Clear();
SR.Clear();
SG.Clear();
SB.Clear();
}
result = subDiff.IndexOf(subDiff.Min()) + minWidth;
break;
case 2:
// 4:2:2
for (int i = minWidth; i < windowSize; i += 2)
{
MR = rgbList[0].Take(listSize - i).ToList();
MG = rgbList[1].Take(listSize - i).ToList();
MB = rgbList[2].Take(listSize - i).ToList();
SR = rgbList[0].Skip(i).ToList();
SG = rgbList[1].Skip(i).ToList();
SB = rgbList[2].Skip(i).ToList();
subDiff.Add(UBDiffSum(MR, MG, MB, SR, SG, SB));
MR.Clear();
MG.Clear();
MB.Clear();
SR.Clear();
SG.Clear();
SB.Clear();
}
result = subDiff.IndexOf(subDiff.Min()) + minWidth / 2;
break;
case 3:
//4:2:0
for (int i = minWidth; i < windowSize; i += 2)
{
MR = rgbList[0].Where((item, index) => index % 4 == 2 || index % 4 == 3).Take(listSize / 2 - i).ToList();
MG = rgbList[1].Where((item, index) => index % 4 == 2 || index % 4 == 3).Take(listSize / 2 - i).ToList();
MB = rgbList[2].Where((item, index) => index % 4 == 2 || index % 4 == 3).Take(listSize / 2 - i).ToList();
SR = rgbList[0].Skip(2 * i).Where((item, index) => index % 4 == 0 || index % 4 == 1).ToList();
SG = rgbList[1].Skip(2 * i).Where((item, index) => index % 4 == 0 || index % 4 == 1).ToList();
SB = rgbList[2].Skip(2 * i).Where((item, index) => index % 4 == 0 || index % 4 == 1).ToList();
subDiff.Add(UBDiffSum(MR, MG, MB, SR, SG, SB));
MR.Clear();
MG.Clear();
MB.Clear();
SR.Clear();
SG.Clear();
SB.Clear();
}
result = subDiff.IndexOf(subDiff.Min()) + minWidth / 2;
break;
}
return(result);
}
private void MenuClear_Click(object sender, RoutedEventArgs e)
{
SB.Clear();
}
//---------------------------------------------------------------------
public void ClearSB()
{
SB.Clear();
}
