OSCR

The neural processes of illusory occlusion in object recognition.

Code ↔ Paper

5 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 5 matches
  1. [1] § Methods › EEG recording and preprocessing ↔ eeg/data/functions.py, lines 30–175 · score 0.96 · low pass filter, 100–800 ms, raw EEG, MNE, stimulus onset, BioSemi
  2. [2] § Methods › EEG decoding analyses ↔ eeg/data/functions.py, lines 183–307 · score 0.66 · cross validation, linear discriminant, classifier, sequences, EEG, decoding
  3. [3] § Methods › Online behavioral experiments ↔ online/experiment1/experiment.js, lines 68–146 · score 0.54 · Western Sydney University, online, consent, behavioral experiments, Pavlovia, SONA
  4. [4] § Methods › EEG experiment ↔ online/experiment1/experiment.js, lines 68–146 · score 0.50 · Western Sydney University, consent, behavioral experiments, epilepsy, history, SONA
  5. [5] § Methods › EEG experiment ↔ online/experiment2/experiment.js, lines 123–178 · score 0.50 · Western Sydney University, consent, behavioral experiments, epilepsy, history, SONA

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 400 lines · 15 KB · no license · 2 matches

  1. import os
  2. import pandas as pd
  3. import numpy as np
  5. import matplotlib.pyplot as plt
  6. from tqdm import tqdm
  7. from sklearn.pipeline import make_pipeline
  8. from sklearn.preprocessing import StandardScaler
  9. from sklearn.linear_model import LogisticRegression,Ridge,LinearRegression
  10. from sklearn.model_selection import GroupKFold,LeaveOneGroupOut
  11. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  12. from sklearn.svm import LinearSVR,LinearSVC
  14. import mne
  15. from mne.decoding import (
  16. SlidingEstimator,
  17. GeneralizingEstimator,
  18. Scaler,
  19. cross_val_multiscore,
  20. LinearModel,
  21. get_coef,
  22. Vectorizer,
  23. CSP,
  24. )
  26. datapath = os.path.expanduser('~/illusory-occlusion/eeg/data')
  28. #%% -------------------------------------------- PREPROCESSING --------------------------------------------
  30. def run_preprocess(subjectnr,overwrite=0):
  31. '''
  32. Preprocess the EEG data of a single subject
  33. This function loads the raw EEG data, preprocesses it, and saves the preprocessed data to a new file.
  35. Parameters
  36. ----------
  37. subjectnr : str
  38. Subject number
  39. overwrite : bool
  40. Overwrite existing files. 0 does not overwrite, 1 overwrites
  42. Returns
  43. -------
  44. Processed EEG data and behavioural data in BIDS format
  46. Notes
  47. -----
  48. high-pass filter: 0.1 Hz
  49. low-pass filter: 100 Hz
  50. resample: 1000 Hz
  51. epoch: -0.1 to 0.8 s relative to stimulus onset
  52. baseline: -0.1 to 0 s
  53. '''
  54. # subject to run
  55. print(f'preprocessing sub-{subjectnr}')
  56. os.makedirs(f'{datapath}\derivatives\mne', exist_ok=True)
  58. outfn = f'{datapath}\derivatives\mne\sub-{subjectnr}_mne_epo.fif'
  59. behavfn = f'{datapath}\sub-{subjectnr}\eeg\sub-{subjectnr}_task-detection_events.tsv'
  60. source_behavfn = f'{datapath}\sourcedata\sub-{subjectnr}_task-detection_events.csv'
  61. source_filename = f'{datapath}\sourcedata\sub-{subjectnr}_task-detection_eeg.bdf'
  62. raw_filename = f'{datapath}\sub-{subjectnr}\eeg\sub-{subjectnr}_task-detection_eeg.bdf'
  64. if os.path.exists(outfn) and not overwrite:
  65. print('file exists:',outfn)
  66. return
  68. if not os.path.exists(source_behavfn):
  69. print('file does not exists:',source_behavfn)
  70. return
  72. if not (os.path.exists(source_filename) or os.path.exists(raw_filename)):
  73. print('file does not exists:',source_filename)
  74. return
  76. if not os.path.exists(raw_filename):
  77. os.makedirs(os.path.dirname(raw_filename), exist_ok=True)
  78. os.rename(source_filename, raw_filename)
  80. # Load EEG file
  81. raw = mne.io.read_raw_bdf(raw_filename, preload=True)
  82. sfreq = raw.info['sfreq']
  84. # Read events
  85. T = pd.read_csv(source_behavfn)
  87. # Find the STATUS channel and read the values from it
  88. stim_channel = raw.ch_names.index('Status')
  89. stim_data = raw.get_data(picks=stim_channel)
  91. # %matplotlib qt
  92. # raw.plot();
  94. triggertimes = [x for x in 1+np.where((np.diff(stim_data)[0]!=0))[0]]
  95. triggervalues = stim_data[0][triggertimes]
  97. a,b = np.unique(triggervalues,return_counts=1)
  98. for x,y in zip(a,b):print('%d %d'%(x,y))
  100. stim_onset_sample = [x for x,y in zip(triggertimes,triggervalues) if y==40708]
  102. seq_onset_sample = [x for x,y in zip(triggertimes,triggervalues) if y==34564]
  104. if subjectnr == '22':
  105. stim_onset_sample = [x for x,y in zip(triggertimes, triggervalues) if y == 40708] #sub 22 - technical error, excluded from sample
  107. elif subjectnr=='26':
  108. stim_onset_sample = [x for x,y in zip(triggertimes,triggervalues) if y==40708] #didn't get preprocessed without doing this
  110. #stim_offset_sample = [x for x,y in zip(triggertimes,triggervalues) if y==40704]
  111. #[(x-y)/sfreq for x,y in list(zip(stim_offset_sample,stim_onset_sample))[:20]]
  113. # fix missing triggers
  114. missingtriggers = len(T)-len(stim_onset_sample)
  115. if missingtriggers>0:
  116. print('reconstructing %i triggers'%(missingtriggers))
  117. print('triggers: %i'%len(stim_onset_sample),'expected: %i'%len(T))
  118. assert missingtriggers<100, 'too many missing triggers'
  119. a=[int(x)/sfreq for x in stim_onset_sample]
  120. b=[x for x in T['time_stimon']]
  121. for j in range(1,len(a)):
  122. da = a[j]-a[j-1]
  123. db = b[j]-b[j-1]
  124. if da-db > .11:
  125. print('inserting pos:%i +%.3fs'%(j,a[j-1]+db),'data:%.3fs_diff(%.3fs,%.3fs])'%(da,a[j-1],a[j]),
  126. 'expected:%.3fs_diff(%.3fs,%.3fs])'%(db,b[j-1],b[j]))
  127. a.insert(j,a[j-1]+db)
  128. stim_onset_sample.insert(j,int(round(sfreq*(a[j-1]+db))))
  129. if len(stim_onset_sample) > len(T):
  130. print('found not enough events!',len(stim_onset_sample), len(T))
  132. assert len(stim_onset_sample) <= len(T), 'found too many events!'
  133. assert len(stim_onset_sample) >= len(T), 'found not enough events!'
  134. stim_onset_sample = np.array(stim_onset_sample)
  135. events = np.transpose(np.vstack((stim_onset_sample,0*stim_onset_sample,range(0,len(stim_onset_sample)))));
  137. # Behaviour
  138. T2 = pd.DataFrame({
  139. 'onset': [int(x)/sfreq for x in stim_onset_sample],
  140. 'duration': 0.20,
  141. 'onsetsample': [int(x) for x in stim_onset_sample],
  142. 'eventnumber': range(0, len(stim_onset_sample)),
  143. 'subjectnr': int(subjectnr)
  144. })
  145. T2 = pd.concat((T2,T),axis=1)
  147. assert all(np.diff(T2['onset']) - np.diff(T2['time_stimon']) < 0.11), 'event times do not seem to match'
  148. T2.to_csv(behavfn, sep='\t', index=False)
  149. T2.to_csv(behavfn.replace('.tsv','.csv'), sep=',', index=False)
  151. # layout = mne.channels.read_layout('biosemi')
  152. # raw.set_montage()
  153. print(raw)
  154. raw.pick('eeg')
  155. if subjectnr=='26':
  156. raw.pick(range(64)) #recorded external electrodes without info, only taking the 64 non-external
  158. montage = mne.channels.make_standard_montage("biosemi64")
  159. #raw.info.ch_names = montage.ch_names
  161. # rename A1 A2 etc to Fp1 AF7 etc
  162. mne.rename_channels(raw.info,dict(zip(raw.info.ch_names,montage.ch_names)))
  163. print(raw.info.ch_names)
  164. raw.set_montage(montage)
  165. raw.set_eeg_reference()
  166. raw.filter(l_freq=0.1, h_freq=100)
  168. epochs = mne.Epochs(raw, events, tmin=-0.1, tmax=0.8, baseline=(-0.1, 0), detrend=0, proj=False, preload=True)
  170. # Resample
  171. epochs.resample(1000)
  172. print(epochs)
  173. epochs.save(outfn,overwrite=1)
  175. print('Done')
  179. #%% -------------------------------------------- DECODING --------------------------------------------
  181. #%%Control decoding
  183. def run_control_decoding(subjectnr, decode, overwrite=0):
  184. """
  185. Run decoding analysis on a single subject
  186. This function loads the preprocessed data and the behavioural data and runs a decoding analysis using a linear discriminant analysis.
  188. Parameters
  189. ----------
  190. subjectnr : str
  191. Subject number
  192. decode : str
  193. Decoding type (position, validity, empty_illusion)
  194. overwrite : bool
  195. Overwrite existing files. 0 does not overwrite, 1 overwrites
  197. Returns
  198. -------
  199. scores : array
  200. The decoding scores
  202. Notes
  203. -----
  204. y : array
  205. The target variable. In this case it is determined by the decoding type (decode parameter)
  206. groups : array
  207. The groups variable. In this case it is the block sequence number.
  208. cv : cross-validation generator
  209. scoring : str
  210. n_jobs : int
  211. verbose : int
  212. """
  214. infn = f'{datapath}/derivatives/mne/sub-{subjectnr}_mne_epo.fif'
  215. behavfn = f'{datapath}/sub-{subjectnr}/eeg/sub-{subjectnr}_task-detection_events.tsv'
  216. outfn = f'{datapath}/derivatives/results_control/sub-{subjectnr}_control_{decode}.csv'
  217. fig1fn = f'{datapath}/derivatives/results_control/figures/sub-{subjectnr}_control_{decode}.png'
  218. fig2fn = f'{datapath}/derivatives/results_control/figures/sub-{subjectnr}_control_{decode}_plot.png'
  220. if os.path.exists(infn) and os.path.exists(behavfn):
  221. if os.path.exists(outfn) and not overwrite:
  222. print('file exists:',outfn)
  223. return
  224. else:
  225. epochs = mne.read_epochs(infn)
  227. avg = epochs.average()
  228. p=avg.plot_joint(show=0)
  229. p.savefig(fig1fn)
  231. T_all = pd.read_csv(behavfn,delimiter='\t')
  232. #idx = ['_invalid_' in x for x in T['stimpath']]
  233. idx = [not x for x in T_all['istarget']]
  234. T = T_all[idx]
  235. X = epochs.get_data()[idx,:,:]
  236. Y = pd.DataFrame({'time':epochs.times})
  238. # applying the decoding
  239. #c,y = np.unique(T['category_name'],return_inverse=True)
  241. if decode == 'position':
  242. y = ['_behind_' in x for x in T['stimpath']]
  243. decode_label = 'behind vs infront'
  244. elif decode == 'validity':
  245. y = ['_valid_' in x for x in T['stimpath']]
  246. decode_label = 'valid vs invalid'
  247. elif decode == 'shape':
  248. y = ['_triangle' in x for x in T['stimpath']]
  249. decode_label = 'triangle vs square'
  251. if decode == 'illusion':
  252. idx = [x == 1 for x in T_all['istarget']] #index of the targets
  253. T = T_all[idx] # T dataframe with only the targets
  254. y = ['invalid_' in x for x in T['stimpath']]
  255. if len(y) == 0:
  256. print('no targets found')
  257. return
  258. decode_label = 'illusion vs no illusion'
  260. groups = np.array(T['blocksequencenumber'])
  261. unique_groups = np.unique(groups)
  262. #print(unique_groups)
  263. if len(unique_groups) < 2:
  264. #in case there are not enough unique groups
  265. print("Not enough unique groups for LeaveOneGroupOut cross-validation.")
  266. else:
  267. groups = T['sequencenumber']
  268. unique_groups = np.unique(groups)
  272. clf = make_pipeline(LinearDiscriminantAnalysis(priors=(1+0*np.unique(y))/len(np.unique(y))))
  273. #clf = make_pipeline(StandardScaler(),LinearModel(LinearSVC(dual="auto")))
  274. time_decod = SlidingEstimator(clf, n_jobs=-1, scoring="balanced_accuracy", verbose=0)
  277. scores = cross_val_multiscore(time_decod, X, y, groups=groups, cv=LeaveOneGroupOut(), n_jobs=-1)
  278. Y[f'{decode}_decoding'] = np.mean(scores, axis=0)
  281. # plot decoding per subject
  282. #overall_y_min = float('inf')
  283. #overall_y_max = float('-inf')
  285. ##for subject_data in range(50):
  286. ### Calculate the y-axis limits for the current subject
  287. #subject_y_min = min(Y[f'{decode}_decoding'].min())
  288. #subject_y_max = max(Y[f'{decode}_decoding'].max())
  290. ### Update the overall minimum and maximum values
  291. #overall_y_min = min(overall_y_min, subject_y_min)
  292. #overall_y_max = max(overall_y_max, subject_y_max)
  293. fig, ax = plt.subplots()
  294. ax.plot(epochs.times, Y[f'{decode}_decoding'], label=decode_label)
  295. ax.axhline(1/len(np.unique(y)), color="k", linestyle="--", label="chance")
  296. ax.set_xlabel("Time (s) relative to stimulus onset")
  297. ax.set_ylabel("Accuracy")
  298. ax.legend()
  299. ax.axvline(0.0, color="k", linestyle="-")
  300. ax.set_title(f"{decode} decoding")
  301. #ax.set_ylim(overall_y_min, overall_y_max)
  302. ax.set_xlim(-0.1, 0.8)
  303. fig.savefig(fig2fn)
  305. Y.to_csv(outfn)
  307. print(f'Control decoding participant {subjectnr} done')
  310. #%% Main decoding
  313. def run_main_decoding(subjectnr,overwrite=0):
  314. """
  315. Run decoding analysis on a single subject
  316. This function loads the preprocessed data and the behavioural data and runs a decoding analysis using a linear discriminant analysis.
  318. Parameters
  319. ----------
  320. subjectnr : str
  321. Subject number
  322. overwrite : bool
  323. Overwrite existing files. 0 does not overwrite, 1 overwrites
  325. """
  326. os.makedirs(f'{datapath}/derivatives/results_main', exist_ok=True)
  327. infn = f'{datapath}/derivatives/mne/sub-{subjectnr}_mne_epo.fif'
  328. behavfn = f'{datapath}/sub-{subjectnr}/eeg/sub-{subjectnr}_task-detection_events.tsv'
  329. fig1fn = f'{datapath}/derivatives/results_main/figures/sub-{subjectnr}_epochs.png'
  331. posval_codes = {'_front_valid_': 'frval', '_front_invalid_': 'frinval',
  332. '_behind_valid_': 'behval', '_behind_invalid_': 'behinval'}
  333. cat_codes = {'supraordinate': 'sup', 'category': 'cat',
  334. 'object': 'obj', 'image': 'im'}
  336. if os.path.exists(infn) and os.path.exists(behavfn) and not overwrite:
  337. epochs = mne.read_epochs(infn)
  339. avg = epochs.average()
  340. p=avg.plot_joint(show=0)
  341. p.savefig(fig1fn)
  343. TT = pd.read_csv(behavfn,delimiter='\t')
  346. for c in posval_codes:
  347. outfn = f'{datapath}/derivatives/results_main/sub-{subjectnr}_results_{posval_codes[c]}.csv'
  349. if not os.path.exists(outfn):
  350. idx = [c in x for x in TT['stimpath']]
  351. T = TT[idx]
  352. X = epochs.get_data()[idx,:,:]
  353. Y = pd.DataFrame({'time':epochs.times})
  356. for l in cat_codes:
  357. print(f'decoding participant {subjectnr} condition {c} category {l}')
  358. # decoding category
  359. #j,y = np.unique([x[5:9] for x in T['stimpath']],return_inverse=True)
  360. #y = ['_triangle' in x for x in T['stimpath']]
  362. supraordinate_y = [int(x[5]) for x in T['stimpath'] if l == list(cat_codes)[0]] #supraordinate
  363. category_y = [int(x[5:7]) for x in T['stimpath'] if l == list(cat_codes)[1]] #category
  365. object_y = [int(x[5:8]) for x in T['stimpath'] if l == list(cat_codes)[2]] #object
  366. image_y = [int(x[5:9]) for x in T['stimpath'] if l == list(cat_codes)[3]] #image
  367. groups = np.array(T['blocksequencenumber'])
  369. if l == list(cat_codes)[0]:
  370. y = supraordinate_y
  371. elif l == list(cat_codes)[1]:
  372. y = category_y
  373. elif l == list(cat_codes)[2]:
  374. y = object_y
  375. elif l == list(cat_codes)[3]:
  376. y = image_y
  378. clf = make_pipeline(LinearDiscriminantAnalysis(priors=(1+0*np.unique(y))/len(np.unique(y))))
  379. #clf = make_pipeline(StandardScaler(),LinearModel(LinearSVC(dual="auto")))
  380. time_decod = SlidingEstimator(clf, n_jobs=-1, scoring="balanced_accuracy", verbose=0)
  381. scores = cross_val_multiscore(time_decod, X, y, groups=groups, cv=LeaveOneGroupOut(), n_jobs=-1)
  383. # Mean scores across cross-validation splits
  384. Y[l] = np.mean(scores, axis=0)
  387. # Plot
  388. fig, ax = plt.subplots()
  389. ax.plot(epochs.times, Y[l], label="score")
  390. ax.axhline(1/len(np.unique(y)), color="k", linestyle="--", label="chance")
  391. ax.set_xlabel("Times")
  392. ax.set_ylabel("Accuracy")
  393. ax.legend()
  394. ax.axvline(0.0, color="k", linestyle="-")
  395. ax.set_title("Category decoding")
  396. fig.savefig(fig1fn.replace('_epochs',f'_decoding-{l}'))
  398. Y.to_csv(outfn)
  399. print('Done')

functions.py, no license · at the source

Overview

Authors: Almudena Ramírez-Haro1, Denise Moerel1, Genevieve L Quek1, Manuel Varlet1,2, Tijl Grootswagers1,3
ORCID iDs: Almudena Ramírez-Haro, Denise Moerel, Genevieve L Quek, Manuel Varlet, Tijl Grootswagers
  1. The MARCS Institute for Brain, Behaviour and Development, Western Sydney University, Sydney, Australia
  2. School of Psychology, Western Sydney University, Sydney, Australia
  3. School of Computer, Data and Mathematical Sciences, Western Sydney University, Sydney, Australia
Institutions: Western Sydney University (Australia)
Journal: Journal of vision, volume 26, issue 8, article 4
Dates: received 29 May 2025; accepted 26 May 2026; published online 19 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1167/jov.26.8.4 · PMID 42615796 · PMCID PMC13505799 · OpenAlex W4410858712
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.05.28.656741
Status: code verified
Categories: EEG (modality), human (organism), cognitive (subfield)
Methods: Machine learning, Preprocessing, Statistics
Keywords: kanizsa, occlusion, EEG
MeSH: Form Perception*, Illusions*, Optical Illusions*, Pattern Recognition, Visual*, Recognition, Psychology*, Electroencephalography, Female, Humans, Male, Photic Stimulation (* major topic)
Topic: Advanced Scientific Research Methods (Food Science, Agricultural and Biological Sciences), according to OpenAlex
Funding: Australian Government (doi.org/10.82133/C42F-K220, https://doi.org/10.82133/C42F-K220, /10.82133/C42F-K220)
Citations: not cited yet (Europe PMC); 77 references in the paper

Abstract

Fast and accurate object recognition is crucial for effective behavior in dynamic visual environments. In some cases, the visual system must overcome ambiguity in visual input during object recognition, such as when an object is partially hidden behind another. Recurrent processing between higher- and lower-order areas is thought to play a role in resolving such ambiguity, enabling the filling in of missing visual information. Here we examined this claim using a novel paradigm in which partial object images appear “occluded” by an illusory Kanizsa figure, perception of which also depends on recurrent processing by the grouping of Pacmen inducers. If both recognizing the partial object and perceiving the illusory shape depend on recurrent processing, object recognition should vary as a function of the presence of illusory shape. Across two behavioral experiments and a separate electroencephalography decoding study, we found no evidence of an interaction between illusion perception and object recognition, as well as different neural time courses for the illusory figures alone compared with partial objects, which were decoded earlier. Ultimately, our study highlights the robustness of the visual system to solve the identity of the ambiguous object, independently of the processing of different ambiguities occurring at the same time, providing new insights into the mechanisms of recurrence in the early and late stages of information processing and its application to ambiguous object recognition.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 5 matches between paragraphs and lines of code.

OSF x6fv9

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Languages: JavaScript (6), Python (3), R (2), Jupyter (2)
Size: 239 files, 13 scripts
Software Heritage: not checked
Found in: the acknowledgements
Holds: environment (requirements.txt), 2 notebooks
Not found: README, license file, CITATION.cff, tests, continuous integration, documentation
Tools: pandas (3 files), BayesFactor (2 files), ggplot2 (2 files), jsPsych (2 files), Matplotlib (2 files), NumPy (2 files), PsychoPy (2 files), tidyverse (2 files), MNE-Python (1 file), scikit-learn (1 file), SciPy (1 file), seaborn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
13 files
At the source: osf.io/x6fv9/

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 13 scripts, each with its path and the digest of its content;
  • 5 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 3, 28 September 2026

  • Authors: added Almudena Ramírez-Haro (0009-0005-5659-9694); Denise Moerel (0000-0001-9677-0170); Genevieve L Quek (0000-0002-5905-8405); Manuel Varlet (0000-0001-5772-2061); Tijl Grootswagers (0000-0002-7961-5002); removed Almudena Ramírez-Haro; Denise Moerel; Genevieve L Quek; Manuel Varlet; Tijl Grootswagers
  • Funding: added Australian Government: doi.org/10.82133/C42F-K220, https://doi.org/10.82133/C42F-K220, /10.82133/C42F-K220

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 3 keywords, 10 MeSH terms, 74 references.

Cite

This paper

Ramírez-Haro, A., Moerel, D., Quek, G. L., Varlet, M., & Grootswagers, T. (2026). The neural processes of illusory occlusion in object recognition. Journal of vision, 26(8), 4. https://doi.org/10.1167/jov.26.8.4

BibTeX

@article{ramirezharo2026neural,
author = {Ramírez-Haro, Almudena and Moerel, Denise and Quek, Genevieve L and Varlet, Manuel and Grootswagers, Tijl},
title = {{The neural processes of illusory occlusion in object recognition}},
journal = {Journal of vision},
year = {2026},
month = aug,
volume = {26},
number = {8},
pages = {4},
publisher = {Association for Research in Vision and Ophthalmology},
issn = {1534-7362},
doi = {10.1167/jov.26.8.4},
url = {https://doi.org/10.1167/jov.26.8.4},
pmid = {42615796},
pmcid = {PMC13505799}
}

RIS

TY - JOUR
AU - Ramírez-Haro, Almudena
AU - Moerel, Denise
AU - Quek, Genevieve L
AU - Varlet, Manuel
AU - Grootswagers, Tijl
TI - The neural processes of illusory occlusion in object recognition
T2 - Journal of vision
J2 - J Vis
PY - 2026
DA - 2026/08/01
VL - 26
IS - 8
SP - 4
SN - 1534-7362
PB - Association for Research in Vision and Ophthalmology
DO - 10.1167/jov.26.8.4
UR - https://doi.org/10.1167/jov.26.8.4
LA - en
ER -

CSL-JSON

{
"id": "10.1167/jov.26.8.4",
"type": "article-journal",
"title": "The neural processes of illusory occlusion in object recognition",
"container-title": "Journal of vision",
"author": [
{
"family": "Ramírez-Haro",
"given": "Almudena"
},
{
"family": "Moerel",
"given": "Denise"
},
{
"family": "Quek",
"given": "Genevieve L"
},
{
"family": "Varlet",
"given": "Manuel"
},
{
"family": "Grootswagers",
"given": "Tijl"
}
],
"container-title-short": "J Vis",
"volume": "26",
"issue": "8",
"page": "4",
"DOI": "10.1167/jov.26.8.4",
"PMID": "42615796",
"PMCID": "PMC13505799",
"ISSN": "1534-7362",
"publisher": "Association for Research in Vision and Ophthalmology",
"URL": "https://doi.org/10.1167/jov.26.8.4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1371/journal.pone.0347992 [code]
Rotation-tolerant representations elucidate the time-course of high-level object processing.
Journal: PloS one
In common: PsychoPy, pandas, NumPy, EEG, cognitive, 15 references, author Denise Moerel
[2] doi:10.1167/jov.26.8.2 [code]
Disentangling objects' contextual associations from perceptual and conceptual attributes using time-resolved neural decoding.
Journal: Journal of vision
In common: seaborn, pandas, SciPy, 2 other tools, EEG, cognitive, 7 references, 2 authors
[3] doi:10.1162/imag.a.1207 [code]
Investigating the temporal dynamics and modeling of mid-level feature representations in humans.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, seaborn, scikit-learn, 4 other tools, EEG, cognitive, 8 references
[4] doi:10.1523/eneuro.0344-25.2026 [code]
Long-Term Variability in Visual Processing versus Perceptual Stability.
Journal: eNeuro
In common: MNE-Python, seaborn, scikit-learn, 4 other tools, cognitive, 5 references
[5] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: BayesFactor, MNE-Python, ggplot2, 7 other tools, cognitive, 2 references
[6] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: BayesFactor, MNE-Python, ggplot2, 7 other tools, 2 references
[7] doi:10.1038/s41597-026-07350-9 [code]
An open multi-center MEG-EEG dataset for studying conscious visual perception.
Journal: Scientific data
In common: BayesFactor, MNE-Python, ggplot2, 7 other tools, EEG, 1 reference
[8] doi:10.3390/s26103131 [code]
Neuromagnetism "On the Cheap": Evaluating a Combined Cylindrical Shield and Partial-Coverage OPM-MEG System for Detecting Sensorimotor Responses in Humans.
Journal: Sensors (Basel, Switzerland)
In common: BayesFactor, MNE-Python, ggplot2, 6 other tools, 2 references
[9] doi:10.34133/csbj.0042 [code]
Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials.
Journal: Computational and structural biotechnology journal
In common: PsychoPy, MNE-Python, ggplot2, 7 other tools, EEG, 1 reference
[10] doi:10.1016/j.isci.2026.117285 [code]
Working memory demands modulate memory brain state engagement.
Journal: iScience
In common: BayesFactor, PsychoPy, MNE-Python, 6 other tools, EEG, cognitive

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.