class Analysis(db.Model):
__tablename__ = 'analysis'
id = db.Column(db.Integer, primary_key=True)
analysis_set_id = db.Column(db.Integer, db.ForeignKey(AnalysisSet.id))
name = db.Column(db.String(100), unique=False)
n_studies = db.Column(db.Integer, default=0)
n_activations = db.Column(db.Integer, default=0)
description = db.Column(db.Text)
type = db.Column(db.String(50))
studies = association_proxy('frequencies', 'study')
# images = db.relationship('AnalysisImage', backref=db.backref('analysis', lazy='joined'), lazy='dynamic')
analysis_set = db.relationship('AnalysisSet', backref=db.backref(
'analyses', cascade='all'))
display = db.Column(db.Boolean)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
__mapper_args__ = {
'polymorphic_identity': 'analysis',
'polymorphic_on': type
}
@property
def reverse_inference_image(self):
""" Convenience method for accessing the reverse inference image. """
return self.images[1]
class TermAnalysis(Analysis):
__tablename__ = 'term_analysis'
id = db.Column(db.Integer, db.ForeignKey('analysis.id'), primary_key=True)
images = db.relationship('TermAnalysisImage', backref=db.backref('analysis',
cascade='all'))
cog_atlas = db.Column(db.Text, nullable=True) # Cognitive Atlas RDF data
__mapper_args__ = {
'polymorphic_identity': 'term'
}
class Gene(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
symbol = db.Column(db.String(20), unique=True)
locus_type = db.Column(db.String(40))
synonyms = db.Column(db.String(200))
images = db.relationship('GeneImage',
backref=db.backref('gene', lazy='joined'),
lazy='dynamic')
class Table(db.Model):
pmid = db.Column(db.Integer, primary_key=True)
doi = db.Column(db.String(200))
title = db.Column(db.String(1000))
authors = db.Column(db.String(1000))
journal = db.Column(db.String(200))
study = db.relationship('Study', backref=db.backref('tables'))
peaks = db.relationship('Peak',
backref=db.backref('table', lazy='joined'),
lazy='dynamic')
analyses = association_proxy('frequencies', 'analyses')
class Download(db.Model):
''' Track all image downloads. '''
id = db.Column(db.Integer, primary_key=True)
image_id = db.Column(db.Integer, db.ForeignKey(Image.id))
image = db.relationship(Image,
backref=db.backref('downloads',
cascade='all, delete-orphan'))
ip = db.Column(db.String(15))
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=True)
user = db.relationship(User,
backref=db.backref('downloads',
cascade='all, delete-orphan'))
class Frequency(db.Model):
analysis_id = db.Column(db.Integer,
db.ForeignKey('analysis.id'),
primary_key=True)
pmid = db.Column(db.Integer, db.ForeignKey('study.pmid'), primary_key=True)
frequency = db.Column(db.Float, default=1.)
analysis = db.relationship(
'Analysis',
backref=db.backref('frequencies', cascade='all, delete-orphan'),
lazy='joined')
study = db.relationship('Study',
backref=db.backref('frequencies',
cascade='all, delete-orphan'),
lazy='joined')
class Location(db.Model):
id = db.Column(db.Integer, primary_key=True)
x = db.Column(db.Float)
y = db.Column(db.Float)
z = db.Column(db.Float)
location_analysis = association_proxy('location_analysis',
'LocationAnalysis')
images = db.relationship(
'LocationImage', backref=db.backref('location', lazy='joined'))
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
class TopicAnalysis(Analysis):
__tablename__ = 'topic_analysis'
id = db.Column(db.Integer, db.ForeignKey('analysis.id'), primary_key=True)
terms = db.Column(db.Text)
number = db.Column(db.Integer)
images = db.relationship('TopicAnalysisImage', backref=db.backref('analysis',
cascade='all'))
__mapper_args__ = {
'polymorphic_identity': 'topic'
}
@property
def reverse_inference_image(self):
""" Convenience method for accessing the reverse inference image. """
return self.images[1]
class AnalysisSet(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=False)
n_analyses = db.Column(db.Integer, default=0)
type = db.Column(db.String(50))
description = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow,
onupdate=datetime.datetime.now)
class DecodingSet(db.Model):
id = db.Column(db.Integer, primary_key=True)
analysis_set_id = db.Column(db.Integer,
db.ForeignKey(AnalysisSet.id),
nullable=True)
analysis_set = db.relationship(AnalysisSet,
backref=db.backref('decoding_set'))
name = db.Column(db.String(20))
n_images = db.Column(db.Integer)
n_voxels = db.Column(db.Integer)
is_subsampled = db.Column(db.Boolean)
class Peak(db.Model):
id = db.Column(db.Integer, primary_key=True)
pmid = db.Column(db.Integer, db.ForeignKey('study.pmid'))
table = db.Column(db.String(10))
x = db.Column(db.Float)
y = db.Column(db.Float)
z = db.Column(db.Float)
@classmethod
def closestPeaks(cls, radius, x, y, z):
'''
Returns an optimized query using euclidean distance to find closest peaks within a radius of x, y, z
'''
# find peaks in a box then run heavier euclidean distance formula on what's left
return Peak.query.filter(
cls.x <= x + radius, cls.x >= x - radius, cls.y <= y + radius,
cls.y >= y - radius, cls.z <= z + radius, cls.z >= z - radius,
(x - cls.x) * (x - cls.x) + (y - cls.y) * (y - cls.y) +
(z - cls.z) * (z - cls.z) <= radius**2)
class Study(db.Model):
pmid = db.Column(db.Integer, primary_key=True)
doi = db.Column(db.String(200))
title = db.Column(db.String(1000))
authors = db.Column(db.String(1000))
journal = db.Column(db.String(200))
year = db.Column(db.Integer)
space = db.Column(db.String(10))
peaks = db.relationship('Peak',
backref=db.backref('study', lazy='joined'),
lazy='dynamic')
analyses = association_proxy('frequencies', 'analysis')
# analyses = association_proxy('inclusions', 'analysis')
def serialize(self):
return {
'pmid': self.pmid,
'authors': self.authors,
'journal': self.journal,
'year': self.year,
'title': '<a href="/studies/%s">%s</a>' % (self.pmid, self.title)
}
class CustomAnalysis(Analysis):
__tablename__ = 'custom_analysis'
id = db.Column(db.Integer, db.ForeignKey('analysis.id'), primary_key=True)
uuid = db.Column(db.String(32), unique=True)
ip = db.Column(db.String(15))
images = db.relationship('CustomAnalysisImage', backref=db.backref('analysis',
cascade='all'))
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User, backref=db.backref('analyses',
cascade='all'))
private = db.Column(db.Boolean, default=False)
last_run_at = db.Column(db.DateTime)
__mapper_args__ = {
'polymorphic_identity': 'custom'
}
def serialize(self):
return dict(id=self.id, uuid=self.uuid, name=self.name,
description=self.description,
studies=[f.pmid for f in self.studies],
private=self.private, user=self.user.username)
class TopicAnalysisImage(Image):
__mapper_args__ = {'polymorphic_identity': 'topic'}
topic_analysis_id = db.Column(db.Integer, db.ForeignKey(TopicAnalysis.id), nullable=True)
class LocationImage(Image):
__mapper_args__ = {'polymorphic_identity': 'location'}
location_id = db.Column(db.Integer, db.ForeignKey(Location.id), nullable=True)
class CustomAnalysisImage(Image):
__mapper_args__ = {'polymorphic_identity': 'custom'}
custom_analysis_id = db.Column(db.Integer, db.ForeignKey(CustomAnalysis.id), nullable=True)
class Decoding(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(255), nullable=True)
neurovault_id = db.Column(db.String(100), nullable=True)
filename = db.Column(db.String(200))
uuid = db.Column(db.String(32), unique=True)
name = db.Column(db.String(200))
comments = db.Column(db.Text, nullable=True)
display = db.Column(db.Boolean)
download = db.Column(db.Boolean)
_data = db.Column('data', db.Text, nullable=True)
ip = db.Column(db.String(15))
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
image_decoded_at = db.Column(db.DateTime,
onupdate=datetime.datetime.utcnow)
image_modified_at = db.Column(db.DateTime, nullable=True)
# Relationships
decoding_set_id = db.Column(db.Integer, db.ForeignKey(DecodingSet.id))
decoding_set = db.relationship(DecodingSet,
backref=db.backref(
'decodings',
cascade='all, delete-orphan'))
image_id = db.Column(db.Integer, db.ForeignKey(Image.id), nullable=True)
image = db.relationship(Image,
backref=db.backref('decodings',
cascade='all, delete-orphan'))
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=True)
user = db.relationship(User,
backref=db.backref('uploads',
cascade='all, delete-orphan'))
@hybrid_property
def data(self):
return json.loads(self._data)
@data.setter
def data(self, value):
self._data = json.dumps(value)
class Snapshot(db.Model):
""" A snapshot of the entire Database (i.e., all studies/activations) at a
given moment in time. """
id = db.Column(db.Integer, primary_key=True)
n_studies = db.Column(db.Integer)
class GeneImage(Image):
__mapper_args__ = {'polymorphic_identity': 'gene'}
gene_id = db.Column(db.Integer, db.ForeignKey(Gene.id), nullable=True)
class Image(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
label = db.Column(db.String(200))
kind = db.Column(db.String(200))
description = db.Column(db.Text)
stat = db.Column(db.String(200))
image_file = db.Column(db.String(200))
display = db.Column(db.Boolean)
download = db.Column(db.Boolean)
type = db.Column(db.String(20))
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow,
onupdate=datetime.datetime.now)
__mapper_args__ = {
'polymorphic_on': type,
'polymorphic_identity': 'image'
}
@property
def uncorrected_image_file(self):
""" Returns an uncorrected version of the filename if one is found. """
if '_FDR' not in self.image_file:
return self.image_file
return self.image_file.split('_FDR')[0] + '.nii.gz'
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean, nullable=False, default=False)
username = db.Column(db.String(64), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, default='')
email = db.Column(db.String(120), unique=True)
reset_password_token = db.Column(db.String(100),
nullable=False,
server_default='')
confirmed_at = db.Column(db.DateTime())
last_ip = db.Column(db.String(15))
logins = db.Column(db.Integer)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
last_login = db.Column(db.DateTime, onupdate=datetime.datetime.utcnow)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='0')
first_name = db.Column(db.String(100), nullable=False, server_default='')
last_name = db.Column(db.String(100), nullable=False, server_default='')
