void setZeroes(vector<vector<int> > &matrix) {
int row = matrix.size();
if(row == 0)
return;
int col = matrix[0].size();
bool first = false;
for(int i = 0; i < col; i++){
if(matrix[0][i] == 0){
first = true;
break;
}
}
for(int i = 1; i < row; i++){
bool zero = false;
for(int j = 0; j < col; j++){
if(matrix[i][j] == 0){
zero = true;
matrix[0][j] = 0;
}
}
if(zero)
setRow(matrix, i, col);
}
for(int i = 0; i < col; i++){
if(matrix[0][i] == 0)
setColumn(matrix, i, row);
}
if(first)
setRow(matrix, 0, col);
}
Matrix4x4::Matrix4x4(float mat[16])
{
setRow(mat[0 * 4 + 0], mat[0 * 4 + 1], mat[0 * 4 + 2], mat[0 * 4 + 3], 0);
setRow(mat[1 * 4 + 0], mat[1 * 4 + 1], mat[1 * 4 + 2], mat[1 * 4 + 3], 1);
setRow(mat[2 * 4 + 0], mat[2 * 4 + 1], mat[2 * 4 + 2], mat[2 * 4 + 3], 2);
setRow(mat[3 * 4 + 0], mat[3 * 4 + 1], mat[3 * 4 + 2], mat[3 * 4 + 3], 3);
}
void Matrix::swapRows(unsigned int index1, unsigned int index2)
{
if(index1 == index2) return;
Matrix temp = getRow(index1);
setRow(index1, getRow(index2));
setRow(index2, temp);
return;
}
Mtx44& Mtx44::identity()
{
setRow(0, 1, 0, 0, 0);
setRow(1, 0, 1, 0, 0);
setRow(2, 0, 0, 1, 0);
setRow(3, 0, 0, 0, 1);
return *this;
}
Matrix2f::Matrix2f( const Vector2f& v0, const Vector2f& v1, bool setColumns )
{
if( setColumns )
{
setCol( 0, v0 );
setCol( 1, v1 );
}
else
{
setRow( 0, v0 );
setRow( 1, v1 );
}
}
void Mtx44::ortho(
float left, float right,
float bottom, float top,
float near, float far)
{
float tx = right - left;
float ty = top - bottom;
float tz = far - near;
setRow(0, 2.f / tx, 0, 0, 0);
setRow(1, 0, 2.f / ty, 0, 0);
setRow(2, 0, 0, -2.f / tz, 0);
setRow(3, -(right + left) / tx, -(top + bottom) / ty, -(far + near) / tz, 1);
}
// Perform inverse on full 4x4 matrix. Used in special cases only, so not at all optimized.
bool MatrixF::fullInverse()
{
Point4F a,b,c,d;
getRow(0,&a);
getRow(1,&b);
getRow(2,&c);
getRow(3,&d);
// det = a0*b1*c2*d3 - a0*b1*c3*d2 - a0*c1*b2*d3 + a0*c1*b3*d2 + a0*d1*b2*c3 - a0*d1*b3*c2 -
// b0*a1*c2*d3 + b0*a1*c3*d2 + b0*c1*a2*d3 - b0*c1*a3*d2 - b0*d1*a2*c3 + b0*d1*a3*c2 +
// c0*a1*b2*d3 - c0*a1*b3*d2 - c0*b1*a2*d3 + c0*b1*a3*d2 + c0*d1*a2*b3 - c0*d1*a3*b2 -
// d0*a1*b2*c3 + d0*a1*b3*c2 + d0*b1*a2*c3 - d0*b1*a3*c2 - d0*c1*a2*b3 + d0*c1*a3*b2
F32 det = a.x*b.y*c.z*d.w - a.x*b.y*c.w*d.z - a.x*c.y*b.z*d.w + a.x*c.y*b.w*d.z + a.x*d.y*b.z*c.w - a.x*d.y*b.w*c.z
- b.x*a.y*c.z*d.w + b.x*a.y*c.w*d.z + b.x*c.y*a.z*d.w - b.x*c.y*a.w*d.z - b.x*d.y*a.z*c.w + b.x*d.y*a.w*c.z
+ c.x*a.y*b.z*d.w - c.x*a.y*b.w*d.z - c.x*b.y*a.z*d.w + c.x*b.y*a.w*d.z + c.x*d.y*a.z*b.w - c.x*d.y*a.w*b.z
- d.x*a.y*b.z*c.w + d.x*a.y*b.w*c.z + d.x*b.y*a.z*c.w - d.x*b.y*a.w*c.z - d.x*c.y*a.z*b.w + d.x*c.y*a.w*b.z;
if (mFabs(det)<0.00001f)
return false;
Point4F aa,bb,cc,dd;
aa.x = b.y*c.z*d.w - b.y*c.w*d.z - c.y*b.z*d.w + c.y*b.w*d.z + d.y*b.z*c.w - d.y*b.w*c.z;
aa.y = -a.y*c.z*d.w + a.y*c.w*d.z + c.y*a.z*d.w - c.y*a.w*d.z - d.y*a.z*c.w + d.y*a.w*c.z;
aa.z = a.y*b.z*d.w - a.y*b.w*d.z - b.y*a.z*d.w + b.y*a.w*d.z + d.y*a.z*b.w - d.y*a.w*b.z;
aa.w = -a.y*b.z*c.w + a.y*b.w*c.z + b.y*a.z*c.w - b.y*a.w*c.z - c.y*a.z*b.w + c.y*a.w*b.z;
bb.x = -b.x*c.z*d.w + b.x*c.w*d.z + c.x*b.z*d.w - c.x*b.w*d.z - d.x*b.z*c.w + d.x*b.w*c.z;
bb.y = a.x*c.z*d.w - a.x*c.w*d.z - c.x*a.z*d.w + c.x*a.w*d.z + d.x*a.z*c.w - d.x*a.w*c.z;
bb.z = -a.x*b.z*d.w + a.x*b.w*d.z + b.x*a.z*d.w - b.x*a.w*d.z - d.x*a.z*b.w + d.x*a.w*b.z;
bb.w = a.x*b.z*c.w - a.x*b.w*c.z - b.x*a.z*c.w + b.x*a.w*c.z + c.x*a.z*b.w - c.x*a.w*b.z;
cc.x = b.x*c.y*d.w - b.x*c.w*d.y - c.x*b.y*d.w + c.x*b.w*d.y + d.x*b.y*c.w - d.x*b.w*c.y;
cc.y = -a.x*c.y*d.w + a.x*c.w*d.y + c.x*a.y*d.w - c.x*a.w*d.y - d.x*a.y*c.w + d.x*a.w*c.y;
cc.z = a.x*b.y*d.w - a.x*b.w*d.y - b.x*a.y*d.w + b.x*a.w*d.y + d.x*a.y*b.w - d.x*a.w*b.y;
cc.w = -a.x*b.y*c.w + a.x*b.w*c.y + b.x*a.y*c.w - b.x*a.w*c.y - c.x*a.y*b.w + c.x*a.w*b.y;
dd.x = -b.x*c.y*d.z + b.x*c.z*d.y + c.x*b.y*d.z - c.x*b.z*d.y - d.x*b.y*c.z + d.x*b.z*c.y;
dd.y = a.x*c.y*d.z - a.x*c.z*d.y - c.x*a.y*d.z + c.x*a.z*d.y + d.x*a.y*c.z - d.x*a.z*c.y;
dd.z = -a.x*b.y*d.z + a.x*b.z*d.y + b.x*a.y*d.z - b.x*a.z*d.y - d.x*a.y*b.z + d.x*a.z*b.y;
dd.w = a.x*b.y*c.z - a.x*b.z*c.y - b.x*a.y*c.z + b.x*a.z*c.y + c.x*a.y*b.z - c.x*a.z*b.y;
setRow(0,aa);
setRow(1,bb);
setRow(2,cc);
setRow(3,dd);
mul(1.0f/det);
return true;
}
void Mtx44::frustum(
float left, float right,
float bottom, float top,
float near, float far)
{
if (near == 0) printf("frustum can't near = 0\n");
float w = right - left;
float h = top - bottom;
float d = far - near;
setRow(0, (2 * near) / w, 0, 0, 0);
setRow(1, 0, (2 * near) / h, 0, 0);
setRow(2, (right + left) / w, (top + bottom) / h, -(far + near) / d, -1);
setRow(3, 0, 0, -(2 * far * near) / d, 0);
}
Matrix3f::Matrix3f( const Vector3f& v0, const Vector3f& v1, const Vector3f& v2, bool setColumns )
{
if( setColumns )
{
setCol( 0, v0 );
setCol( 1, v1 );
setCol( 2, v2 );
}
else
{
setRow( 0, v0 );
setRow( 1, v1 );
setRow( 2, v2 );
}
}
void GameScene::addEndLine()
{
auto b = Block::createBlocks(winSize, Color3B::GREEN, "Congratulations", 30, Color3B::WHITE);
b->setPosition(0, winSize.height);
b->setRow(4);
gameLayer->addChild(b);
}
void parseWhereFrom(QueryData &results, const std::string &path) {
CFStringRef CFPath = CFStringCreateWithCString(
kCFAllocatorDefault, path.c_str(), kCFStringEncodingUTF8);
MDItemRef metadata = MDItemCreate(kCFAllocatorDefault, CFPath);
CFRelease(CFPath);
if (metadata == nullptr) {
VLOG(1) << "Metadata for " << path << " is null";
return;
}
CFTypeRef attributes;
attributes = MDItemCopyAttribute(metadata, kMDItemWhereFroms);
CFRelease(metadata);
if (attributes == nullptr) {
VLOG(1) << "No attributes found for " << path;
return;
}
CFArrayRef attribs = (CFArrayRef)attributes;
CFIndex count = CFArrayGetCount(attribs);
for (CFIndex i = 0; i < count; i++) {
CFStringRef attribute = (CFStringRef)CFArrayGetValueAtIndex(attribs, i);
auto where_from_attribute = stringFromCFString(attribute);
if (!where_from_attribute.empty()) {
setRow(results, path, "where_from", where_from_attribute);
}
}
CFRelease(attributes);
}
RtlRow::RtlRow(const RtlRecord & _info, const void * optRow, unsigned numOffsets, size_t * _variableOffsets) : info(_info), variableOffsets(_variableOffsets)
{
assertex(numOffsets == info.getNumVarFields()+1);
//variableOffset[0] is used for all fixed offset fields to avoid any special casing.
variableOffsets[0] = 0;
setRow(optRow);
}
void Grid::extendUp()
{
int r,c,i;
for ( r = 1; r < nrows; r++ ) {
for ( c = 0; c < ncols; c++ ) {
QWidget* w = cell( r, c );
if ( !w )
continue;
int cr = countRow( r, c);
int stretch = 0;
for ( i = r-1; i >= 0; i-- ) {
if ( cell( i, c ) )
break;
if ( countRow( i, c ) < cr )
break;
if ( isWidgetEndRow( i ) )
break;
if ( isWidgetStartRow( i ) ) {
stretch = r - i;
break;
}
}
if ( stretch ) {
for ( i = 0; i < stretch; i++ )
setRow( r-i-1, c, w, cr );
}
}
}
}
void Mtx44::lookat(const Vec3& eye, const Vec3& target, const Vec3& up)
{
/*
[note] z軸はカメラ位置から視線方向へのベクトル。
x軸はz軸と上方向に垂直なので両者の外積。
y軸はz軸とx軸に垂直なので両者の外積。
平行移動成分は各軸に対してカメラ位置に合うように移動。
*/
Vec3 zaxis = (eye - target).getNormalized();
Vec3 xaxis = up.getCrossed(zaxis).getNormalized();
Vec3 yaxis = zaxis.getCrossed(xaxis);
setRow(0, xaxis.x, yaxis.x, zaxis.x, 0);
setRow(1, xaxis.y, yaxis.y, zaxis.y, 0);
setRow(2, xaxis.z, yaxis.z, zaxis.z, 0);
setRow(3, -xaxis.dot(eye), -yaxis.dot(eye), -zaxis.dot(eye), 1);
}
void IconImpl::read(Reader &input)
{
setIcon(input.read<int>());
setCol(input.read<int>());
setRow(input.read<int>());
setNr(input.read<int>());
}
void FavoriteEditor::on_down_button_clicked() {
int row = table->currentRow();
qDebug("FavoriteEditor::on_down_button_clicked: current_row: %d", row);
if ((row+1) >= table->rowCount()) return;
// take whole rows
QList<QTableWidgetItem*> source_items = takeRow(row);
QList<QTableWidgetItem*> dest_items = takeRow(row+1);
// set back in reverse order
setRow(row, dest_items);
setRow(row+1, source_items);
table->setCurrentCell(row+1, table->currentColumn());
}
void Grid::extendDown()
{
int r,c,i;
for ( r = nrows - 2; r >= 0; r-- ) {
for ( c = 0; c < ncols; c++ ) {
QWidget* w = cell( r, c );
if ( !w )
continue;
int cr = countRow( r, c);
int stretch = 0;
for ( i = r+1; i < nrows; i++ ) {
if ( cell( i, c ) )
break;
if ( countRow( i, c ) < cr )
break;
if ( isWidgetStartRow( i ) )
break;
if ( isWidgetEndRow( i ) ) {
stretch = i - r;
break;
}
}
if ( stretch ) {
for ( i = 0; i < stretch; i++ )
setRow( r+i+1, c, w, cr );
}
}
}
}
//------------------------------------------------------------------------------
void TController::LoadInformation()
{
DataManager->LoadData();
setRow(DataManager->returnTable());
DisplayManager->ShowKHR(vKHRList);
DisplayManager->showExecutors(vKHRList);
}
void QgsVectorLayerProperties::loadRows()
{
QObject::disconnect( tblAttributes, SIGNAL( cellChanged( int, int ) ), this, SLOT( on_tblAttributes_cellChanged( int, int ) ) );
const QgsFieldMap &fields = layer->pendingFields();
tblAttributes->clear();
tblAttributes->setColumnCount( attrColCount );
tblAttributes->setRowCount( fields.size() );
tblAttributes->setHorizontalHeaderItem( attrIdCol, new QTableWidgetItem( tr( "Id" ) ) );
tblAttributes->setHorizontalHeaderItem( attrNameCol, new QTableWidgetItem( tr( "Name" ) ) );
tblAttributes->setHorizontalHeaderItem( attrTypeCol, new QTableWidgetItem( tr( "Type" ) ) );
tblAttributes->setHorizontalHeaderItem( attrLengthCol, new QTableWidgetItem( tr( "Length" ) ) );
tblAttributes->setHorizontalHeaderItem( attrPrecCol, new QTableWidgetItem( tr( "Precision" ) ) );
tblAttributes->setHorizontalHeaderItem( attrCommentCol, new QTableWidgetItem( tr( "Comment" ) ) );
tblAttributes->setHorizontalHeaderItem( attrEditTypeCol, new QTableWidgetItem( tr( "Edit widget" ) ) );
tblAttributes->setHorizontalHeaderItem( attrAliasCol, new QTableWidgetItem( tr( "Alias" ) ) );
tblAttributes->horizontalHeader()->setResizeMode( 1, QHeaderView::Stretch );
tblAttributes->horizontalHeader()->setResizeMode( 7, QHeaderView::Stretch );
tblAttributes->setSelectionBehavior( QAbstractItemView::SelectRows );
tblAttributes->setSelectionMode( QAbstractItemView::ExtendedSelection );
tblAttributes->verticalHeader()->hide();
int row = 0;
for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); it++, row++ )
setRow( row, it.key(), it.value() );
tblAttributes->resizeColumnsToContents();
QObject::connect( tblAttributes, SIGNAL( cellChanged( int, int ) ), this, SLOT( on_tblAttributes_cellChanged( int, int ) ) );
}
void QgsVectorLayerProperties::loadRows()
{
const QgsFieldMap &fields = layer->pendingFields();
tblAttributes->clear();
tblAttributes->setColumnCount( 8 );
tblAttributes->setRowCount( fields.size() );
tblAttributes->setHorizontalHeaderItem( 0, new QTableWidgetItem( tr( "id" ) ) );
tblAttributes->setHorizontalHeaderItem( 1, new QTableWidgetItem( tr( "name" ) ) );
tblAttributes->setHorizontalHeaderItem( 2, new QTableWidgetItem( tr( "type" ) ) );
tblAttributes->setHorizontalHeaderItem( 3, new QTableWidgetItem( tr( "length" ) ) );
tblAttributes->setHorizontalHeaderItem( 4, new QTableWidgetItem( tr( "precision" ) ) );
tblAttributes->setHorizontalHeaderItem( 5, new QTableWidgetItem( tr( "comment" ) ) );
tblAttributes->setHorizontalHeaderItem( 6, new QTableWidgetItem( tr( "edit widget" ) ) );
tblAttributes->setHorizontalHeaderItem( 7, new QTableWidgetItem( tr( "values" ) ) );
tblAttributes->setSelectionBehavior( QAbstractItemView::SelectRows );
tblAttributes->setSelectionMode( QAbstractItemView::MultiSelection );
int row = 0;
for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); it++, row++ )
setRow( row, it.key(), it.value() );
tblAttributes->resizeColumnsToContents();
}
void FoW::set(int x0, int y0, int radius, FogStatus value) {
/* FIXME: split this method into two and don't update the neighbours of
* internal tiles */
if (radius == 0) {
int x = x0, y = y0;
if (!contains(x, y) || status[y][x] == value)
return;
status[y][x] = value;
if (value == REVEALED)
setTile(x, y, NONE);
else
updateTile(x, y);
updateNeighbours(x, y);
}
else {
int f = 1 - radius;
int ddF_x = 1;
int ddF_y = -2 * radius;
int x = 0;
int y = radius;
set(x0, y0 - radius, 0, value);
set(x0, y0 + radius, 0, value);
setRow(x0 - radius, x0 + radius, y0, value);
while (x < y) {
// ddF_x == 2 * x + 1;
// ddF_y == -2 * y;
// f == x*x + y*y - radius*radius + 2*x - y + 1;
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
setRow(x0 - x, x0 + x, y0 + y, value);
setRow(x0 - x, x0 + x, y0 - y, value);
setRow(x0 - y, x0 + y, y0 + x, value);
setRow(x0 - y, x0 + y, y0 - x, value);
}
}
}
void QgsVectorLayerProperties::attributeAdded( int idx )
{
const QgsFieldMap &fields = layer->pendingFields();
int row = tblAttributes->rowCount();
tblAttributes->insertRow( row );
setRow( row, idx, fields[idx] );
tblAttributes->setCurrentCell( row, idx );
}
FontRowTable::FontRowTable( QWidget* parent, const char* name ) :
QFrame(parent,name)
{
setBackgroundMode(PaletteBase);
setFrameStyle(Panel|Sunken);
setMargin(8);
setRow(0);
}
Matrix4f::Matrix4f( const Vector4f& v0, const Vector4f& v1, const Vector4f& v2, const Vector4f& v3, bool setColumns )
{
if( setColumns )
{
setCol( 0, v0 );
setCol( 1, v1 );
setCol( 2, v2 );
setCol( 3, v3 );
}
else
{
setRow( 0, v0 );
setRow( 1, v1 );
setRow( 2, v2 );
setRow( 3, v3 );
}
}
IconImpl::IconImpl(int icon,int col,int row,int nr)
{
setDefaults();
setIcon(icon);
setCol(col);
setRow(row);
setNr(nr);
}
caDoubleTabWidget::caDoubleTabWidget(QWidget *parent) : QWidget(parent)
{
row = 0;
col = 0;
vCount = 0;
tableIndex = new QLineEdit("empty");
// create horizontal bar, vertical buttongroup and a stacked widget
hTabBar = new QTabBar;
viewPort = new QStackedWidget;
viewPort->setFrameShape(QFrame::Panel);
vTabBar = new QButtonGroup;
buttonLayout = new QVBoxLayout();
buttonLayout->setSpacing(0);
QVBoxLayout* buttonStretchLayout = new QVBoxLayout();
buttonStretchLayout->setSpacing(0);
buttonStretchLayout->addLayout(buttonLayout);
buttonStretchLayout->addStretch();
// make layout and add the widgets
QGridLayout *gridLayout = new QGridLayout(this);
gridLayout->addWidget(hTabBar, 0, 1, 1, 1);
gridLayout->addLayout(buttonStretchLayout, 1, 0, 1, 1);
gridLayout->addWidget(viewPort, 1, 1, 1, 1);
gridLayout->addWidget(tableIndex, 2, 1, 1, 1);
hTabBar->setShape(QTabBar::TriangularNorth);
hTabBar->setExpanding(true);
// size policy
viewPort->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
hTabBar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
// signal /slots
connect(hTabBar, SIGNAL(currentChanged(int)), SLOT(setCol(int)));
connect(vTabBar, SIGNAL(buttonClicked(int)), this, SLOT(setRow(int)));
// add items to our bar and list
thisVerItems.clear();
thisHorItems.clear();
addSampleWidget(0);
addSampleWidget(1);
addPages = false;
// colorize horizontal bar
QPalette pal = hTabBar->palette();
pal.setColor(QPalette::Base, QColor(255, 0, 255));
hTabBar->setPalette(pal);
setRow(0);
setCol(0);
installEventFilter(this);
}
void QgsValueMapConfigDlg::setConfig( const QVariantMap &config )
{
tableWidget->clearContents();
for ( int i = tableWidget->rowCount() - 1; i > 0; i-- )
{
tableWidget->removeRow( i );
}
int row = 0;
QVariantMap values = config.value( QStringLiteral( "map" ) ).toMap();
for ( QVariantMap::ConstIterator mit = values.constBegin(); mit != values.constEnd(); mit++, row++ )
{
if ( mit.value().isNull() )
setRow( row, mit.key(), QString() );
else
setRow( row, mit.value().toString(), mit.key() );
}
}
CvMat* triangulate(const CvMat* P1, const CvMat* P2, const CvPoint2D32f& x1, const CvPoint2D32f& x2) {
CvMat* A = cvCreateMat(4, 4, CV_64FC1);
CvMat* p1t = getRow(P1, 0);
CvMat* p2t = getRow(P1, 1);
CvMat* p3t = getRow(P1, 2);
CvMat* xp3t = scale(p3t, x1.x);
CvMat* a1 = sub(xp3t, p1t);
CvMat* yp3t = scale(p3t, x1.y);
CvMat* a2 = sub(yp3t, p2t);
CvMat* p1t2 = getRow(P2, 0);
CvMat* p2t2 = getRow(P2, 1);
CvMat* p3t2 = getRow(P2, 2);
CvMat* xp3t2 = scale(p3t2, x2.x);
CvMat* a3 = sub(xp3t2, p1t2);
CvMat* yp3t2 = scale(p3t2, x2.y);
CvMat* a4 = sub(yp3t2, p2t2);
setRow(A, a1, 0);
setRow(A, a2, 1);
setRow(A, a3, 2);
setRow(A, a4, 3);
cvReleaseMat(&p1t);
cvReleaseMat(&p2t);
cvReleaseMat(&p3t);
cvReleaseMat(&xp3t);
cvReleaseMat(&yp3t);
cvReleaseMat(&p1t2);
cvReleaseMat(&p2t2);
cvReleaseMat(&p3t2);
cvReleaseMat(&xp3t2);
cvReleaseMat(&yp3t2);
cvReleaseMat(&a1);
cvReleaseMat(&a2);
cvReleaseMat(&a3);
cvReleaseMat(&a4);
return null(A);
}
//alternative constructor that determines team based on an int
Developer::Developer (int rowIn, int colIn, int colorIn)
{
if (colorIn == 0)
player = GREEN;
if (colorIn == 1)
player = YELLOW;
setRow (rowIn);
setCol (colIn);
pieceType = 6;
}
void QgsGlobePluginDialog::moveRow( QTableWidget* widget, bool up )
{
//moves QTableWidget row up or down
if ( widget->selectedItems().count() > 0 )
{
const int sourceRow = widget->currentItem()->row();
const int destRow = ( up ? sourceRow - 1 : sourceRow + 1 );
if ( destRow >= 0 && destRow < widget->rowCount() )
{
// take whole rows
QList<QTableWidgetItem*> sourceItems = takeRow( widget, sourceRow );
QList<QTableWidgetItem*> destItems = takeRow( widget, destRow );
// set back in reverse order
setRow( widget, sourceRow, destItems );
setRow( widget, destRow, sourceItems );
widget->selectRow( destRow );
}
}
}
