double IllusionExcelFile::GetCellDouble(long irow, long icolumn)
{
double rtn_value = 0;
COleVariant vresult;
//字符串
if (already_preload_ == FALSE)
{
CRange range;
range.AttachDispatch(excel_current_range_.get_Item(COleVariant((long)irow), COleVariant((long)icolumn)).pdispVal, true);
vresult = range.get_Value2();
range.ReleaseDispatch();
}
//如果数据依据预先加载了
else
{
long read_address[2];
VARIANT val;
read_address[0] = irow;
read_address[1] = icolumn;
ole_safe_array_.GetElement(read_address, &val);
vresult = val;
}
if (vresult.vt == VT_R8)
{
rtn_value = vresult.dblVal;
}
return rtn_value;
}
void IllusionExcelFile::FreezePanes(const TCHAR* cell){
CRange range = excel_work_sheet_.get_Range(COleVariant(cell), COleVariant(cell));
range.Select();
CWindow0 mwin = excel_application_.get_ActiveWindow();
mwin.put_FreezePanes(1);
range.ReleaseDispatch();
}
//VT_R8
int IllusionExcelFile::GetCellInt(long irow, long icolumn)
{
int num;
COleVariant vresult;
if (already_preload_ == FALSE)
{
CRange range;
range.AttachDispatch(excel_current_range_.get_Item(COleVariant((long)irow), COleVariant((long)icolumn)).pdispVal, true);
vresult = range.get_Value2();
range.ReleaseDispatch();
}
else
{
long read_address[2];
VARIANT val;
read_address[0] = irow;
read_address[1] = icolumn;
ole_safe_array_.GetElement(read_address, &val);
vresult = val;
}
//
num = static_cast<int>(vresult.dblVal);
return num;
}
void Cwhu_FaxSettingDlg::Lin_ImportAutoForArr(CString m_FilePath,CStringArray &m_AutoForward)
{
int Number = 0;
//m_DutyArr数组必须足够大//
//导入
CApplication app;
CWorkbook book;
CWorkbooks books;
CWorksheet sheet;
CWorksheets sheets;
CRange range;
LPDISPATCH lpDisp;
//定义变量//
COleVariant covOptional((long)
DISP_E_PARAMNOTFOUND,VT_ERROR);
if (!app.CreateDispatch(_T("Excel.Application")))
{
this->MessageBox(_T("无法创建Excel应用"));
}
books = app.get_Workbooks();
//打开Excel，其中m_FilePath为Excel表的路径名//
lpDisp = books.Open(m_FilePath,covOptional
,covOptional,covOptional,covOptional
,covOptional,covOptional,covOptional
,covOptional,covOptional,covOptional
,covOptional,covOptional,covOptional
,covOptional);
book.AttachDispatch(lpDisp);
sheets = book.get_Worksheets();
sheet = sheets.get_Item(COleVariant((short)1));
CStringArray m_ContentArr;
for (int ItemNum = 2;ItemNum<40;ItemNum++)
{
for (int ColumNum=1;ColumNum<11;ColumNum++)
{
CString m_pos = Lin_GetEnglishCharacter(ColumNum);
CString m_Itempos;
m_Itempos.Format(_T("%d"),ItemNum);
CString m_str = m_pos+m_Itempos;
range = sheet.get_Range(COleVariant(m_str),COleVariant(m_str));
//获得单元格的内容
COleVariant rValue;
rValue = COleVariant(range.get_Value2());
//转换成宽字符//
rValue.ChangeType(VT_BSTR);
//转换格式，并输出//
CString m_content = CString(rValue.bstrVal);
if (m_content!=_T(""))
{
m_AutoForward.Add(m_content);
}
}
}
book.put_Saved(TRUE);
app.Quit();
}
CString Illusion_ExcelFile::get_cell_cstring(long iline, long icolumn)
{
COleVariant vResult ;
CString str;
//字符串
if (already_preload_ == FALSE)
{
CRange range;
_variant_t v_row(iline);
_variant_t v_column(icolumn);
range.AttachDispatch(excel_current_range_.get_Item(v_row, v_column).pdispVal, true);
vResult = range.get_Value2();
range.ReleaseDispatch();
}
//如果数据依据预先加载了
else
{
long read_address[2];
VARIANT val;
read_address[0] = iline;
read_address[1] = icolumn;
ole_safe_array_.GetElement(read_address, &val);
vResult = val;
}
if (vResult.vt == VT_BSTR)
{
str = vResult.bstrVal;
}
//整数
else if (vResult.vt == VT_INT)
{
str.Format(_T("%d"), vResult.pintVal);
}
//8字节的数字
else if (vResult.vt == VT_R8)
{
str.Format(_T("%.6f"), vResult.dblVal);
}
//时间格式
else if (vResult.vt == VT_DATE)
{
SYSTEMTIME st;
VariantTimeToSystemTime(vResult.date, &st);
CTime tm(st);
str = tm.Format(_T("%Y-%m-%d"));
}
//单元格空的
else if (vResult.vt == VT_EMPTY)
{
str = "";
}
return str;
}
pair<double, bool> CScoreUniqSeqCoverage::MakeScore(CBioseq_Handle const& query_handle, vector<CSeq_align const*>::const_iterator begin, vector<CSeq_align const*>::const_iterator end)
{
CConstRef<CBioseq> bioseq = query_handle.GetCompleteBioseq();
unsigned int qlen = 0;
if ( !bioseq.Empty() && bioseq->IsSetLength()) {
qlen = bioseq->GetLength();
}
if ( !qlen ) {
return make_pair(0, false);
}
bool isDenDiag = ( (*begin)->GetSegs().Which() == CSeq_align::C_Segs::e_Dendiag) ?
true : false;
CRangeCollection<TSeqPos> subj_rng_coll((*begin)->GetSeqRange(1));
CRange<TSeqPos> q_rng((*begin)->GetSeqRange(0));
CRangeCollection<TSeqPos> query_rng_coll(s_FixMinusStrandRange(q_rng));
for( ++begin; begin != end; ++begin ) {
const CRange<TSeqPos> align_subj_rng((*begin)->GetSeqRange(1));
// subject range should always be on the positive strand
assert(align_subj_rng.GetTo() > align_subj_rng.GetFrom());
CRangeCollection<TSeqPos> coll(align_subj_rng);
coll.Subtract(subj_rng_coll);
if ( coll.empty() ) {
continue;
}
if(coll[0] == align_subj_rng) {
CRange<TSeqPos> query_rng ((*begin)->GetSeqRange(0));
query_rng_coll += s_FixMinusStrandRange(query_rng);
subj_rng_coll += align_subj_rng;
}
else {
ITERATE (CRangeCollection<TSeqPos>, uItr, coll) {
CRange<TSeqPos> query_rng;
const CRange<TSeqPos> & subj_rng = (*uItr);
CRef<CSeq_align> densegAln;
if ( isDenDiag) {
densegAln = CreateDensegFromDendiag(**begin);
}
CAlnMap map( (isDenDiag) ? densegAln->GetSegs().GetDenseg() : (*begin)->GetSegs().GetDenseg());
TSignedSeqPos subj_aln_start = map.GetAlnPosFromSeqPos(1,subj_rng.GetFrom());
TSignedSeqPos subj_aln_end = map.GetAlnPosFromSeqPos(1,subj_rng.GetTo());
query_rng.SetFrom(map.GetSeqPosFromAlnPos(0,subj_aln_start));
query_rng.SetTo(map.GetSeqPosFromAlnPos(0,subj_aln_end));
query_rng_coll += s_FixMinusStrandRange(query_rng);
subj_rng_coll += subj_rng;
}
}
}
template<class CRange> CHashMap(CRange& cRange)
{
size_t iCapacity = cRange.GetLength();
m_pBuffer = new CType[iCapacity];
m_iCapacity = iCapacity;
m_iLength = 0;
while (!cRange.IsEmpty())
PushBack(cRange.PopFront());
}
void CGeneFinder::CGeneSearchPlugin::setUpFeatureIterator (
CBioseq_Handle &ignored_bioseq_handle,
auto_ptr<CFeat_CI> &feat_ci,
TSeqPos circular_length,
CRange<TSeqPos> &range,
const CSeq_loc& loc,
SAnnotSelector &sel,
CScope &scope,
ENa_strand &strand )
{
if ( m_BioseqHandle ) {
// if we're circular, we may need to split our range into two pieces
if( ( circular_length != kInvalidSeqPos ) &&
( range.GetFrom() > range.GetTo() ))
{
// For circular locations, the "from" is greater than the "to", which
// would not work properly if given to CFeat_CI.
// So, as a work around, we transform the range
// into a mix location of the form "join(0..to, from..MAXINT)"
CRef<CSeq_loc> new_loc( new CSeq_loc );
new_loc->SetInt().SetFrom( 0 );
new_loc->SetInt().SetTo( range.GetTo() );
CRef<CSeq_loc> otherHalfOfRange( new CSeq_loc );
otherHalfOfRange->SetInt().SetFrom( range.GetFrom() );
otherHalfOfRange->SetInt().SetTo( kMax_Int );
new_loc->Add( *otherHalfOfRange );
new_loc->SetStrand( loc.GetStrand() );
new_loc->SetId( *loc.GetId() );
feat_ci.reset( new CFeat_CI(scope, *new_loc, sel) );
} else {
// remove far parts, if necessary
bool loc_change_needed = false;
ITERATE( CSeq_loc, loc_iter, loc ) {
if( ! m_BioseqHandle.IsSynonym( loc_iter.GetSeq_id() ) ) {
loc_change_needed = true;
break;
}
}
if( loc_change_needed ) {
CRef<CSeq_loc> new_loc( new CSeq_loc );
ITERATE( CSeq_loc, loc_iter, loc ) {
if( m_BioseqHandle.IsSynonym( loc_iter.GetSeq_id() ) ) {
new_loc->Add( *loc_iter.GetRangeAsSeq_loc() );
}
}
feat_ci.reset( new CFeat_CI(scope, *new_loc, sel) );
} else {
feat_ci.reset( new CFeat_CI(scope, loc, sel) );
}
}
} else {
CSeqMap_CI::CSeqMap_CI(const CConstRef<CSeqMap>& seqMap,
CScope* scope,
const SSeqMapSelector& sel,
const CRange<TSeqPos>& range)
: m_Scope(scope),
m_SearchPos(range.GetFrom()),
m_SearchEnd(range.GetToOpen())
{
x_Select(seqMap, sel, range.GetFrom());
}
CSeqMap_CI::CSeqMap_CI(const CBioseq_Handle& bioseq,
const SSeqMapSelector& sel,
const CRange<TSeqPos>& range)
: m_Scope(&bioseq.GetScope()),
m_SearchPos(range.GetFrom()),
m_SearchEnd(range.GetToOpen())
{
SSeqMapSelector tse_sel(sel);
tse_sel.SetLinkUsedTSE(bioseq.GetTSE_Handle());
x_Select(ConstRef(&bioseq.GetSeqMap()), tse_sel, range.GetFrom());
}
bool AbuttingWith(const CEquivRange& Other) const {
if(Strand != Other.Strand)
return false;
if (!Query.AbuttingWith(Other.Query) ||
!Subjt.AbuttingWith(Other.Subjt))
return false;
return true;
}
///检查一个CELL是否是时间
BOOL IllusionExcelFile::IsCellTime(long iRow, long iColumn)
{
CRange range;
range.AttachDispatch(excel_current_range_.get_Item(COleVariant((long)iRow), COleVariant((long)iColumn)).pdispVal, true);
COleVariant vResult = range.get_Value2();
if (vResult.vt == VT_DATE)
{
return TRUE;
}
range.ReleaseDispatch();
return FALSE;
}
//检查一个CELL是否是数值
BOOL CExcelFile::IsCellInt(long irow, long icolumn)
{
CRange range;
range.AttachDispatch(excel_current_range_.get_Item (COleVariant((long)irow),COleVariant((long)icolumn)).pdispVal, true);
COleVariant vResult =range.get_Value2();
//好像一般都是VT_R8
if(vResult.vt == VT_INT || vResult.vt == VT_R8)
{
return TRUE;
}
return FALSE;
}
BOOL IllusionExcelFile::IsCellString(long irow, long icolumn)
{
CRange range;
range.AttachDispatch(excel_current_range_.get_Item(COleVariant((long)irow), COleVariant((long)icolumn)).pdispVal, true);
COleVariant vResult = range.get_Value2();
//VT_BSTR标示字符串
if (vResult.vt == VT_BSTR)
{
return TRUE;
}
return FALSE;
}
//检查一个CELL是否是数值
BOOL Illusion_ExcelFile::is_cell_number(long iline, long icolumn)
{
CRange range;
_variant_t v_row((long)iline);
_variant_t v_column((long)icolumn);
range.AttachDispatch(excel_current_range_.get_Item(v_row, v_column).pdispVal, true);
VARIANT vResult = range.get_Value2();
//好像一般都是VT_R8
if (vResult.vt == VT_INT || vResult.vt == VT_R8)
{
return TRUE;
}
return FALSE;
}
//检查一个CELL是否是字符串
BOOL Illusion_ExcelFile::is_cell_string(long irow, long icolumn)
{
CRange range;
_variant_t v_row((long)irow);
_variant_t v_column((long)icolumn);
range.AttachDispatch(excel_current_range_.get_Item(v_row, v_column).pdispVal, true);
COleVariant vResult = range.get_Value2();
//VT_BSTR标示字符串
if (vResult.vt == VT_BSTR)
{
return TRUE;
}
return FALSE;
}
CRef<CSeq_loc> CFeatTrim::Apply(const CSeq_loc& loc,
const CRange<TSeqPos>& range)
{
const bool set_partial = true;
const TSeqPos from = range.GetFrom();
const TSeqPos to = range.GetTo();
CRef<CSeq_loc> trimmed_loc(new CSeq_loc());
trimmed_loc->Assign(loc);
x_TrimLocation(from, to, set_partial, trimmed_loc);
return trimmed_loc;
}
void CFootBotMotorGroundRotZOnlySensor::Update() {
/*
* We make the assumption that the robot is rotated only wrt to Z
*/
/* Get robot position and orientation */
const CVector3& cEntityPos = m_pcEmbodiedEntity->GetOriginAnchor().Position;
const CQuaternion& cEntityRot = m_pcEmbodiedEntity->GetOriginAnchor().Orientation;
CRadians cRotZ, cRotY, cRotX;
cEntityRot.ToEulerAngles(cRotZ, cRotY, cRotX);
/* Set robot center */
CVector2 cCenterPos(cEntityPos.GetX(), cEntityPos.GetY());
/* Position of sensor on the ground after rototranslation */
CVector2 cSensorPos;
/* Go through the sensors */
for(UInt32 i = 0; i < m_tReadings.size(); ++i) {
/* Calculate sensor position on the ground */
cSensorPos = m_pcGroundSensorEntity->GetSensor(i).Offset;
cSensorPos.Rotate(cRotZ);
cSensorPos += cCenterPos;
/* Get the color */
const CColor& cColor = m_pcFloorEntity->GetColorAtPoint(cSensorPos.GetX(),
cSensorPos.GetY());
/* Set the reading */
m_tReadings[i].Value = cColor.ToGrayScale() / 255.0f;
/* Apply noise to the sensor */
if(m_bAddNoise) {
m_tReadings[i].Value += m_pcRNG->Uniform(m_cNoiseRange);
}
/* Clamp the reading between 0 and 1 */
UNIT.TruncValue(m_tReadings[i].Value);
}
}
//得到行的总数
long Illusion_ExcelFile::row_count()
{
CRange range;
CRange usedRange;
usedRange.AttachDispatch(excel_work_sheet_.get_UsedRange(), true);
range.AttachDispatch(usedRange.get_Rows(), true);
long count = range.get_Count();
usedRange.ReleaseDispatch();
range.ReleaseDispatch();
return count;
}
//得到列的总数
int CExcelFile::GetColumnCount()
{
CRange range;
CRange usedRange;
usedRange.AttachDispatch(excel_work_sheet_.get_UsedRange(), true);
range.AttachDispatch(usedRange.get_Columns(), true);
int count = range.get_Count();
usedRange.ReleaseDispatch();
range.ReleaseDispatch();
return count;
}
//得到行的总数
int IllusionExcelFile::GetRowCount()
{
CRange range;
CRange usedRange;
usedRange.AttachDispatch(excel_work_sheet_.get_UsedRange(), true);
range.AttachDispatch(usedRange.get_Rows(), true);
int count = range.get_Count();
usedRange.ReleaseDispatch();
range.ReleaseDispatch();
return count;
}
ComboBox::ComboBox(const IRect &rect, int drop_size, const char *prefix, CRange<const char*> values)
:Window(rect), m_drop_size(drop_size), m_prefix(prefix) {
m_button = make_shared<Button>(IRect(int2(0, 0), rect.size()), "");
m_dummy = make_shared<ListBox>(IRect(0, 0, 10, 10));
attach(m_button);
for(auto value : values)
addEntry(value, ColorId::white);
if(!values.empty())
selectEntry(0);
}
// Description:
//
// Arguments:
//
// Return:
//
bool CPersonalRangeSignaling::AddRangeSignal( float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData *pData /*=NULL*/ )
{
CRY_ASSERT( m_bInit == true );
CRY_ASSERT( sSignal != NULL );
CRY_ASSERT( fRadius > 0.5f );
CRY_ASSERT( fBoundary >= 0.0f );
bool bRet = true;
CRange* pRange = SearchRange( sSignal, m_vecRanges );
if( pRange == NULL )
{
pRange = new CRange( this );
m_vecRanges.push_back( pRange );
}
pRange->Init( fRadius, fBoundary, sSignal, pData );
std::sort( m_vecRanges.begin(), m_vecRanges.end(), &CompareRange ); // std::less is properly overridden
return( bRet );
}
void COpenExcelDlg::Lin_InportExcelToList(CString m_FilePath,CListCtrl &m_List)
{
//先删除列表内容//
m_List.DeleteAllItems();
while(m_List.GetHeaderCtrl()->GetItemCount()>0)
{
m_List.DeleteColumn(0);
}
//导入
CApplication app;
CWorkbook book;
CWorkbooks books;
CWorksheet sheet;
CWorksheets sheets;
CRange range;
LPDISPATCH lpDisp;
//定义变量//
COleVariant covOptional((long)
DISP_E_PARAMNOTFOUND,VT_ERROR);
if (!app.CreateDispatch(_T("Excel.Application")))
{
this->MessageBox(_T("无法创建Excel应用"));
return;
}
books = app.get_Workbooks();
//打开Excel，其中m_FilePath为Excel表的路径名//
lpDisp = books.Open(m_FilePath,covOptional
,covOptional,covOptional,covOptional
,covOptional,covOptional,covOptional
,covOptional,covOptional,covOptional
,covOptional,covOptional,covOptional
,covOptional);
book.AttachDispatch(lpDisp);
sheets = book.get_Worksheets();
sheet = sheets.get_Item(COleVariant((short)1));
CStringArray m_HeadName;
for (int i=1;i<26;i++)
{
CString m_pos = Lin_GetEnglishCharacter(i);
m_pos = m_pos + _T("1");
range = sheet.get_Range(COleVariant(m_pos),COleVariant(m_pos));
//获得单元格的内容
COleVariant rValue;
rValue = COleVariant(range.get_Value2());
//转换成宽字符//
rValue.ChangeType(VT_BSTR);
//转换格式，并输出//
CString m_content = CString(rValue.bstrVal);
if (m_content!=_T(""))
{
m_HeadName.Add(m_content);
}
}
Lin_InitList(m_List,m_HeadName);
CStringArray m_ContentArr;
for (int ItemNum = 0;ItemNum<10000;ItemNum++)
{
for (int j=1;j<m_List.GetHeaderCtrl()->GetItemCount();j++)
{
CString m_pos = Lin_GetEnglishCharacter(j);
CString m_Itempos;
m_Itempos.Format(_T("%d"),ItemNum+2);
CString m_str = m_pos+m_Itempos;
range = sheet.get_Range(COleVariant(m_str),COleVariant(m_str));
//获得单元格的内容
COleVariant rValue;
rValue = COleVariant(range.get_Value2());
//转换成宽字符//
rValue.ChangeType(VT_BSTR);
//转换格式，并输出//
CString m_content = CString(rValue.bstrVal);
m_ContentArr.Add(m_content);
}
if (m_ContentArr.GetAt(0)!=_T(""))
{
Lin_InsertList(m_List,m_ContentArr);
m_ContentArr.RemoveAll();
}
else{
break;
}
}
book.put_Saved(TRUE);
app.Quit();
}
bool IntersectingWith(const CEquivRange& Other) const {
return (Query.IntersectingWith(Other.Query) ||
Subjt.IntersectingWith(Other.Subjt));
}
bool NotEmpty() const {
return (Query.NotEmpty() && Subjt.NotEmpty());
}
bool Empty() const {
return (Query.Empty() || Subjt.Empty());
}
namespace argos {
/****************************************/
/****************************************/
static CRange<Real> UNIT(0.0f, 1.0f);
/****************************************/
/****************************************/
CFootBotMotorGroundRotZOnlySensor::CFootBotMotorGroundRotZOnlySensor() :
m_pcEmbodiedEntity(NULL),
m_pcFloorEntity(NULL),
m_pcGroundSensorEntity(NULL),
m_pcRNG(NULL),
m_bAddNoise(false),
m_cSpace(CSimulator::GetInstance().GetSpace()) {}
/****************************************/
/****************************************/
void CFootBotMotorGroundRotZOnlySensor::SetRobot(CComposableEntity& c_entity) {
m_pcEmbodiedEntity = &(c_entity.GetComponent<CEmbodiedEntity>("body"));
m_pcGroundSensorEntity = &(c_entity.GetComponent<CGroundSensorEquippedEntity>("ground_sensors"));
m_pcGroundSensorEntity->SetCanBeEnabledIfDisabled(true);
m_pcGroundSensorEntity->Enable();
m_pcFloorEntity = &m_cSpace.GetFloorEntity();
}
/****************************************/
/****************************************/
void CFootBotMotorGroundRotZOnlySensor::Init(TConfigurationNode& t_tree) {
try {
CCI_FootBotMotorGroundSensor::Init(t_tree);
/* Parse noise level */
Real fNoiseLevel = 0.0f;
GetNodeAttributeOrDefault(t_tree, "noise_level", fNoiseLevel, fNoiseLevel);
if(fNoiseLevel < 0.0f) {
THROW_ARGOSEXCEPTION("Can't specify a negative value for the noise level of the foot-bot ground sensor");
}
else if(fNoiseLevel > 0.0f) {
m_bAddNoise = true;
m_cNoiseRange.Set(-fNoiseLevel, fNoiseLevel);
m_pcRNG = CRandom::CreateRNG("argos");
}
m_tReadings.resize(4);
}
catch(CARGoSException& ex) {
THROW_ARGOSEXCEPTION_NESTED("Initialization error in foot-bot rotzonly ground sensor", ex);
}
}
/****************************************/
/****************************************/
void CFootBotMotorGroundRotZOnlySensor::Update() {
/*
* We make the assumption that the robot is rotated only wrt to Z
*/
/* Get robot position and orientation */
const CVector3& cEntityPos = m_pcEmbodiedEntity->GetOriginAnchor().Position;
const CQuaternion& cEntityRot = m_pcEmbodiedEntity->GetOriginAnchor().Orientation;
CRadians cRotZ, cRotY, cRotX;
cEntityRot.ToEulerAngles(cRotZ, cRotY, cRotX);
/* Set robot center */
CVector2 cCenterPos(cEntityPos.GetX(), cEntityPos.GetY());
/* Position of sensor on the ground after rototranslation */
CVector2 cSensorPos;
/* Go through the sensors */
for(UInt32 i = 0; i < m_tReadings.size(); ++i) {
/* Calculate sensor position on the ground */
cSensorPos = m_pcGroundSensorEntity->GetSensor(i).Offset;
cSensorPos.Rotate(cRotZ);
cSensorPos += cCenterPos;
/* Get the color */
const CColor& cColor = m_pcFloorEntity->GetColorAtPoint(cSensorPos.GetX(),
cSensorPos.GetY());
/* Set the reading */
m_tReadings[i].Value = cColor.ToGrayScale() / 255.0f;
/* Apply noise to the sensor */
if(m_bAddNoise) {
m_tReadings[i].Value += m_pcRNG->Uniform(m_cNoiseRange);
}
/* Clamp the reading between 0 and 1 */
UNIT.TruncValue(m_tReadings[i].Value);
}
}
/****************************************/
/****************************************/
void CFootBotMotorGroundRotZOnlySensor::Reset() {
for(UInt32 i = 0; i < GetReadings().size(); ++i) {
m_tReadings[i].Value = 0.0f;
}
}
/****************************************/
/****************************************/
REGISTER_SENSOR(CFootBotMotorGroundRotZOnlySensor,
"footbot_motor_ground", "rot_z_only",
"Carlo Pinciroli [[email protected]]",
"1.0",
"The foot-bot motor ground sensor.",
"This sensor accesses the foot-bot motor ground sensor. For a complete description\n"
"of its usage, refer to the ci_footbot_motor_ground_sensor.h interface. For the XML\n"
"configuration, refer to the default ground sensor.\n",
"Usable"
);
}
void COpenExcelDlg::Lin_ExportListToExcel(CListCtrl &m_List)
{
if (m_List.GetHeaderCtrl()->GetItemCount()>0)
{
CApplication app;
CWorkbooks books;
CWorkbook book;
CWorksheets sheets;
CWorksheet sheet;
CRange range;
CRange cols;
int i = 3;
CString str1, str2;
COleVariant covOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);
if( !app.CreateDispatch(_T("Excel.Application")))
{
MessageBox(_T("无法创建Excel应用！"));
return;
}
books=app.get_Workbooks();
book=books.Add(covOptional);
sheets=book.get_Sheets();
sheet=sheets.get_Item(COleVariant((short)1));
//写入表头//
for (int ColumNum=1;ColumNum<m_List.GetHeaderCtrl()->GetItemCount();ColumNum++)
{
str2 = Lin_GetEnglishCharacter(ColumNum);
str2 = str2 + _T("1");
LVCOLUMN lvColumn;
TCHAR strChar[256];
lvColumn.pszText=strChar;
lvColumn.cchTextMax=256 ;
lvColumn.mask = LVCF_TEXT;
m_List.GetColumn(ColumNum,&lvColumn);
CString str=lvColumn.pszText;
range=sheet.get_Range(COleVariant(str2),COleVariant(str2));
range.put_Value2(COleVariant(str));
}
//获取单元格的位置//
for (int ColumNum =1;ColumNum<m_List.GetHeaderCtrl()->GetItemCount();ColumNum++)
{
for (int ItemNum = 0;ItemNum<m_List.GetItemCount();ItemNum++)
{
str2 = Lin_GetEnglishCharacter(ColumNum);
str1.Format(_T("%d"),ItemNum+2);
str2 = str2+str1;
CString str = m_List.GetItemText(ItemNum,ColumNum);
range=sheet.get_Range(COleVariant(str2),COleVariant(str2));
range.put_Value2(COleVariant(str));
}
}
cols=range.get_EntireColumn();
cols.AutoFit();
app.put_Visible(TRUE);
app.put_UserControl(TRUE);
}else{
AfxMessageBox(_T("列表为空"));
}
}
CRef<CSeq_feat> CFeatTrim::Apply(const CSeq_feat& feat,
const CRange<TSeqPos>& range)
{
CRef<CSeq_loc> loc = Ref(new CSeq_loc());
loc->Assign(feat.GetLocation());
const TSeqPos from = range.GetFrom();
const TSeqPos to = range.GetTo();
const bool set_partial = true;
x_TrimLocation(from, to, set_partial, loc);
if (loc->IsNull()) {
return Ref(new CSeq_feat());
}
// Create a new seq-feat with the trimmed location
CRef<CSeq_feat> new_sf(new CSeq_feat());
new_sf->Assign(feat);
new_sf->SetLocation(*loc);
if (!loc->IsNull() &&
(loc->IsPartialStart(eExtreme_Biological) ||
loc->IsPartialStop(eExtreme_Biological))) {
new_sf->SetPartial(true);
}
// If Cdregion need to consider changes in frameshift
if (new_sf->GetData().IsCdregion()) {
const TSeqPos offset = x_GetStartOffset(feat, from, to);
x_UpdateFrame(offset, new_sf->SetData().SetCdregion());
if (new_sf->SetData().SetCdregion().IsSetCode_break()) {
// iterate over code breaks and remove if they fall outside the range
list<CRef<CCode_break>>& code_breaks = new_sf->SetData().SetCdregion().SetCode_break();
code_breaks.remove_if(SOutsideRange(from,to));
if (code_breaks.empty()) {
new_sf->SetData().SetCdregion().ResetCode_break();
}
else {
const auto strand = loc->GetStrand();
// Trim the 3' end
if (strand != eNa_strand_minus) {
for (auto code_break : code_breaks) {
const TSeqPos cb_to = code_break->GetLoc().GetTotalRange().GetTo();
if (cb_to > to) {
x_TrimCodeBreak(from, to, *code_break);
}
}
}
else { // strand == eNa_strand_minus
for (auto code_break : code_breaks) {
const TSeqPos cb_from = code_break->GetLoc().GetTotalRange().GetFrom();
if (cb_from < from) {
x_TrimCodeBreak(from, to, *code_break);
}
}
}
}
}
}
else
if (new_sf->GetData().GetSubtype() == CSeqFeatData::eSubtype_tRNA) {
auto& rna = new_sf->SetData().SetRna();
if (rna.IsSetExt() && rna.GetExt().IsTRNA()) {
x_TrimTrnaExt(from, to, rna.SetExt().SetTRNA());
}
}
return new_sf;
}